diff --git a/src/components/Executions/ExecutionDetails/RelaunchExecutionForm.tsx b/src/components/Executions/ExecutionDetails/RelaunchExecutionForm.tsx
index 17d86b807..ed9ce53ff 100644
--- a/src/components/Executions/ExecutionDetails/RelaunchExecutionForm.tsx
+++ b/src/components/Executions/ExecutionDetails/RelaunchExecutionForm.tsx
@@ -1,44 +1,129 @@
import { WaitForData } from 'components/common';
-import { useWorkflow } from 'components/hooks';
-import { LaunchWorkflowForm } from 'components/Launch/LaunchWorkflowForm/LaunchWorkflowForm';
-import { useExecutionLaunchConfiguration } from 'components/Launch/LaunchWorkflowForm/useExecutionLaunchConfiguration';
-import { getWorkflowInputs } from 'components/Launch/LaunchWorkflowForm/utils';
-import { Execution, Workflow } from 'models';
+import { useAPIContext } from 'components/data/apiContext';
+import { fetchStates, useFetchableData } from 'components/hooks';
+import { LaunchForm } from 'components/Launch/LaunchForm/LaunchForm';
+import {
+ TaskInitialLaunchParameters,
+ WorkflowInitialLaunchParameters
+} from 'components/Launch/LaunchForm/types';
+import { fetchAndMapExecutionInputValues } from 'components/Launch/LaunchForm/useMappedExecutionInputValues';
+import {
+ getTaskInputs,
+ getWorkflowInputs
+} from 'components/Launch/LaunchForm/utils';
+import { Execution } from 'models';
import * as React from 'react';
+import { isSingleTaskExecution } from './utils';
export interface RelaunchExecutionFormProps {
execution: Execution;
onClose(): void;
}
-const RenderForm: React.FC
= ({ execution, onClose, workflow }) => {
- const { workflowId } = execution.closure;
- const workflowInputs = getWorkflowInputs(workflow);
- const launchConfiguration = useExecutionLaunchConfiguration({
- execution,
- workflowInputs
- });
+function useRelaunchWorkflowFormState({
+ execution
+}: RelaunchExecutionFormProps) {
+ const apiContext = useAPIContext();
+ const initialParameters = useFetchableData<
+ WorkflowInitialLaunchParameters,
+ Execution
+ >(
+ {
+ defaultValue: {} as WorkflowInitialLaunchParameters,
+ doFetch: async execution => {
+ const {
+ closure: { workflowId },
+ spec: { launchPlan }
+ } = execution;
+ const workflow = await apiContext.getWorkflow(workflowId);
+ const inputDefinitions = getWorkflowInputs(workflow);
+ const values = await fetchAndMapExecutionInputValues(
+ {
+ execution,
+ inputDefinitions
+ },
+ apiContext
+ );
+ return { values, launchPlan, workflowId };
+ }
+ },
+ execution
+ );
+ return { initialParameters };
+}
+
+function useRelaunchTaskFormState({ execution }: RelaunchExecutionFormProps) {
+ const apiContext = useAPIContext();
+ const initialParameters = useFetchableData<
+ TaskInitialLaunchParameters,
+ Execution
+ >(
+ {
+ defaultValue: {} as TaskInitialLaunchParameters,
+ doFetch: async execution => {
+ const {
+ spec: { launchPlan: taskId }
+ } = execution;
+ const task = await apiContext.getTask(taskId);
+ const inputDefinitions = getTaskInputs(task);
+ const values = await fetchAndMapExecutionInputValues(
+ {
+ execution,
+ inputDefinitions
+ },
+ apiContext
+ );
+ return { values, taskId };
+ }
+ },
+ execution
+ );
+ return { initialParameters };
+}
+
+const RelaunchTaskForm: React.FC = props => {
+ const { initialParameters } = useRelaunchTaskFormState(props);
+ const {
+ spec: { launchPlan: taskId }
+ } = props.execution;
return (
-
-
+
+ {initialParameters.state.matches(fetchStates.LOADED) ? (
+
+ ) : null}
);
};
-
-/** For a given execution, fetches the associated workflow and renders a
- * `LaunchWorkflowForm` based on the workflow, launch plan, and inputs of the
- * execution. */
-export const RelaunchExecutionForm: React.FC = props => {
- const workflow = useWorkflow(props.execution.closure.workflowId);
+const RelaunchWorkflowForm: React.FC = props => {
+ const { initialParameters } = useRelaunchWorkflowFormState(props);
+ const {
+ closure: { workflowId }
+ } = props.execution;
return (
-
- {() => }
+
+ {initialParameters.state.matches(fetchStates.LOADED) ? (
+
+ ) : null}
);
};
+
+/** For a given execution, fetches the associated Workflow/Task and renders a
+ * `LaunchForm` based on the same source with input values taken from the execution. */
+export const RelaunchExecutionForm: React.FC = props => {
+ return isSingleTaskExecution(props.execution) ? (
+
+ ) : (
+
+ );
+};
diff --git a/src/components/Executions/ExecutionDetails/constants.ts b/src/components/Executions/ExecutionDetails/constants.ts
index ec298b1d8..4c56659b4 100644
--- a/src/components/Executions/ExecutionDetails/constants.ts
+++ b/src/components/Executions/ExecutionDetails/constants.ts
@@ -3,6 +3,7 @@ export enum ExecutionMetadataLabels {
domain = 'Domain',
duration = 'Duration',
time = 'Time',
+ relatedTo = 'Related to',
version = 'Version'
}
@@ -20,3 +21,5 @@ export const tabs = {
export const executionActionStrings = {
clone: 'Clone Execution'
};
+
+export const backLinkTitle = 'Back to parent';
diff --git a/src/components/Executions/ExecutionDetails/test/ExecutionDetailsAppBarContent.test.tsx b/src/components/Executions/ExecutionDetails/test/ExecutionDetailsAppBarContent.test.tsx
index 6410dd8b8..c64724fcb 100644
--- a/src/components/Executions/ExecutionDetails/test/ExecutionDetailsAppBarContent.test.tsx
+++ b/src/components/Executions/ExecutionDetails/test/ExecutionDetailsAppBarContent.test.tsx
@@ -9,13 +9,14 @@ import {
ExecutionContext,
ExecutionContextData
} from 'components/Executions/contexts';
-import { Execution } from 'models';
+import { Execution, Identifier, ResourceType } from 'models';
import { createMockExecution } from 'models/__mocks__/executionsData';
import { WorkflowExecutionPhase } from 'models/Execution/enums';
import * as React from 'react';
import { MemoryRouter } from 'react-router';
+import { Routes } from 'routes';
import { delayedPromise, DelayedPromiseResult } from 'test/utils';
-import { executionActionStrings } from '../constants';
+import { backLinkTitle, executionActionStrings } from '../constants';
import { ExecutionDetailsAppBarContent } from '../ExecutionDetailsAppBarContent';
jest.mock('components/Navigation/NavBarContent', () => ({
@@ -27,9 +28,11 @@ describe('ExecutionDetailsAppBarContent', () => {
let executionContext: ExecutionContextData;
let mockTerminateExecution: jest.Mock>;
let terminatePromise: DelayedPromiseResult;
+ let sourceId: Identifier;
beforeEach(() => {
execution = createMockExecution();
+ sourceId = execution.closure.workflowId;
mockTerminateExecution = jest.fn().mockImplementation(() => {
terminatePromise = delayedPromise();
return terminatePromise;
@@ -95,4 +98,59 @@ describe('ExecutionDetailsAppBarContent', () => {
expect(queryByLabelText(commonLabels.moreOptionsButton)).toBeNull();
});
});
+
+ it('renders a back link to the parent workflow', async () => {
+ const { getByTitle } = renderContent();
+ await waitFor(() =>
+ expect(getByTitle(backLinkTitle)).toHaveAttribute(
+ 'href',
+ Routes.WorkflowDetails.makeUrl(
+ sourceId.project,
+ sourceId.domain,
+ sourceId.name
+ )
+ )
+ );
+ });
+
+ it('renders the workflow name in the app bar content', async () => {
+ const { getByText } = renderContent();
+ const { project, domain } = execution.id;
+ await waitFor(() =>
+ expect(
+ getByText(`${project}/${domain}/${sourceId.name}/`)
+ ).toBeInTheDocument()
+ );
+ });
+
+ describe('for single task executions', () => {
+ beforeEach(() => {
+ execution.spec.launchPlan.resourceType = ResourceType.TASK;
+ sourceId = execution.spec.launchPlan;
+ });
+
+ it('renders a back link to the parent task', async () => {
+ const { getByTitle } = renderContent();
+ await waitFor(() =>
+ expect(getByTitle(backLinkTitle)).toHaveAttribute(
+ 'href',
+ Routes.TaskDetails.makeUrl(
+ sourceId.project,
+ sourceId.domain,
+ sourceId.name
+ )
+ )
+ );
+ });
+
+ it('renders the task name in the app bar content', async () => {
+ const { getByText } = renderContent();
+ const { project, domain } = execution.id;
+ await waitFor(() =>
+ expect(
+ getByText(`${project}/${domain}/${sourceId.name}/`)
+ ).toBeInTheDocument()
+ );
+ });
+ });
});
diff --git a/src/components/Executions/ExecutionDetails/test/ExecutionMetadata.test.tsx b/src/components/Executions/ExecutionDetails/test/ExecutionMetadata.test.tsx
index 1975b8c18..ef5b23290 100644
--- a/src/components/Executions/ExecutionDetails/test/ExecutionMetadata.test.tsx
+++ b/src/components/Executions/ExecutionDetails/test/ExecutionMetadata.test.tsx
@@ -1,8 +1,10 @@
import { render } from '@testing-library/react';
import { dashedValueString } from 'common/constants';
-import { Execution } from 'models';
+import { Execution, WorkflowExecutionIdentifier } from 'models';
import { createMockExecution } from 'models/__mocks__/executionsData';
import * as React from 'react';
+import { MemoryRouter } from 'react-router';
+import { Routes } from 'routes';
import { ExecutionMetadataLabels } from '../constants';
import { ExecutionMetadata } from '../ExecutionMetadata';
@@ -17,7 +19,11 @@ describe('ExecutionMetadata', () => {
});
const renderMetadata = () =>
- render();
+ render(
+
+
+
+ );
it('shows cluster name if available', () => {
const { getByTestId } = renderMetadata();
@@ -57,4 +63,18 @@ describe('ExecutionMetadata', () => {
dashedValueString
);
});
+
+ it('shows reference execution if it exists', () => {
+ const referenceExecution: WorkflowExecutionIdentifier = {
+ project: 'project',
+ domain: 'domain',
+ name: '123abc'
+ };
+ execution.spec.metadata.referenceExecution = referenceExecution;
+ const { getByText } = renderMetadata();
+ expect(getByText(referenceExecution.name)).toHaveAttribute(
+ 'href',
+ Routes.ExecutionDetails.makeUrl(referenceExecution)
+ );
+ });
});
diff --git a/src/components/Executions/ExecutionDetails/test/RelaunchExecutionForm.test.tsx b/src/components/Executions/ExecutionDetails/test/RelaunchExecutionForm.test.tsx
new file mode 100644
index 000000000..32dcee7b3
--- /dev/null
+++ b/src/components/Executions/ExecutionDetails/test/RelaunchExecutionForm.test.tsx
@@ -0,0 +1,251 @@
+import { render, waitFor } from '@testing-library/react';
+import { mockAPIContextValue } from 'components/data/__mocks__/apiContext';
+import { APIContext, APIContextValue } from 'components/data/apiContext';
+import { mockSimpleVariables } from 'components/Launch/LaunchForm/__mocks__/mockInputs';
+import { primitiveLiteral } from 'components/Launch/LaunchForm/__mocks__/utils';
+import { LaunchForm } from 'components/Launch/LaunchForm/LaunchForm';
+import {
+ LaunchFormProps,
+ LiteralValueMap
+} from 'components/Launch/LaunchForm/types';
+import {
+ createInputCacheKey,
+ getInputDefintionForLiteralType
+} from 'components/Launch/LaunchForm/utils';
+import {
+ Execution,
+ ExecutionData,
+ getExecutionData,
+ getRemoteLiteralMap,
+ getTask,
+ getWorkflow,
+ LiteralMap,
+ ResourceType,
+ Task,
+ Variable,
+ Workflow
+} from 'models';
+import { createMockExecution } from 'models/__mocks__/executionsData';
+import { createMockTask } from 'models/__mocks__/taskData';
+import {
+ createMockWorkflow,
+ createMockWorkflowClosure
+} from 'models/__mocks__/workflowData';
+import * as React from 'react';
+import { long } from 'test/utils';
+import { RelaunchExecutionForm } from '../RelaunchExecutionForm';
+
+const mockContentString = 'launchFormRendered';
+const simpleStringValue = 'abcdefg';
+const simpleIntegerValue = long(123456);
+
+jest.mock('components/Launch/LaunchForm/LaunchForm', () => ({
+ LaunchForm: jest.fn(() => mockContentString)
+}));
+
+function createValuesMap(
+ inputDefinitions: Record,
+ { literals }: LiteralMap
+): LiteralValueMap {
+ return Object.entries(inputDefinitions).reduce((out, [name, input]) => {
+ out.set(
+ createInputCacheKey(
+ name,
+ getInputDefintionForLiteralType(input.type)
+ ),
+ literals[name]
+ );
+ return out;
+ }, new Map());
+}
+
+describe('RelaunchExecutionForm', () => {
+ let apiContext: APIContextValue;
+ let execution: Execution;
+ let executionData: ExecutionData;
+ let executionInputs: LiteralMap;
+ let workflow: Workflow;
+ let task: Task;
+ let taskInputDefinitions: Record;
+ let workflowInputDefinitions: Record;
+ let onClose: jest.Mock;
+ let mockGetWorkflow: jest.Mock>;
+ let mockGetTask: jest.Mock>;
+ let mockGetExecutionData: jest.Mock>;
+ let mockGetRemoteLiteralMap: jest.Mock>;
+
+ beforeEach(() => {
+ onClose = jest.fn();
+ execution = createMockExecution();
+ workflow = createMockWorkflow('MyWorkflow');
+ workflow.closure = createMockWorkflowClosure();
+ task = createMockTask('MyTask');
+ executionData = {
+ inputs: { url: 'http://somePath', bytes: long(1000) },
+ outputs: {}
+ };
+
+ mockGetWorkflow = jest.fn().mockResolvedValue(workflow);
+ mockGetTask = jest.fn().mockResolvedValue(task);
+ mockGetExecutionData = jest.fn().mockResolvedValue(executionData);
+ mockGetRemoteLiteralMap = jest.fn().mockResolvedValue({});
+ apiContext = mockAPIContextValue({
+ getExecutionData: mockGetExecutionData,
+ getRemoteLiteralMap: mockGetRemoteLiteralMap,
+ getTask: mockGetTask,
+ getWorkflow: mockGetWorkflow
+ });
+ });
+
+ const renderForm = () =>
+ render(
+
+
+
+ );
+
+ const checkLaunchFormProps = (props: Partial) => {
+ expect(LaunchForm).toHaveBeenCalledWith(
+ expect.objectContaining(props),
+ expect.anything()
+ );
+ };
+
+ it('passes original execution as a referenceExecution', async () => {
+ const { getByText } = renderForm();
+ await waitFor(() => getByText(mockContentString));
+ checkLaunchFormProps({
+ referenceExecutionId: execution.id
+ });
+ });
+
+ describe('with workflow execution', () => {
+ let values: LiteralValueMap;
+ beforeEach(() => {
+ workflowInputDefinitions = {
+ workflowSimpleString: mockSimpleVariables.simpleString,
+ workflowSimpleInteger: mockSimpleVariables.simpleInteger
+ };
+
+ workflow.closure!.compiledWorkflow!.primary.template.interface!.inputs = {
+ variables: workflowInputDefinitions
+ };
+
+ executionInputs = {
+ literals: {
+ workflowSimpleString: primitiveLiteral({
+ stringValue: simpleStringValue
+ }),
+ workflowSimpleInteger: primitiveLiteral({
+ integer: simpleIntegerValue
+ })
+ }
+ };
+ execution.closure.computedInputs = executionInputs;
+ mockGetRemoteLiteralMap.mockResolvedValue(executionInputs);
+
+ values = createValuesMap(workflowInputDefinitions, executionInputs);
+ });
+
+ it('passes workflowId to LaunchForm', async () => {
+ const { getByText } = renderForm();
+ await waitFor(() => getByText(mockContentString));
+ checkLaunchFormProps({
+ workflowId: execution.closure.workflowId
+ });
+ });
+
+ it('maps execution input values to workflow inputs', async () => {
+ const { getByText } = renderForm();
+ await waitFor(() => getByText(mockContentString));
+
+ checkLaunchFormProps({
+ initialParameters: expect.objectContaining({
+ values
+ })
+ });
+ });
+
+ it('correctly fetches remote execution inputs', async () => {
+ delete execution.closure.computedInputs;
+ const { getByText } = renderForm();
+ await waitFor(() => getByText(mockContentString));
+ expect(mockGetExecutionData).toHaveBeenCalledWith(execution.id);
+ expect(mockGetRemoteLiteralMap).toHaveBeenCalledWith(
+ executionData.inputs.url
+ );
+ checkLaunchFormProps({
+ initialParameters: expect.objectContaining({
+ values
+ })
+ });
+ });
+ });
+
+ describe('with single task execution', () => {
+ let values: LiteralValueMap;
+ beforeEach(() => {
+ execution.spec.launchPlan.resourceType = ResourceType.TASK;
+ taskInputDefinitions = {
+ taskSimpleString: mockSimpleVariables.simpleString,
+ taskSimpleInteger: mockSimpleVariables.simpleInteger
+ };
+ task.closure.compiledTask.template.interface!.inputs = {
+ variables: taskInputDefinitions
+ };
+
+ executionInputs = {
+ literals: {
+ taskSimpleString: primitiveLiteral({
+ stringValue: simpleStringValue
+ }),
+ taskSimpleInteger: primitiveLiteral({
+ integer: simpleIntegerValue
+ })
+ }
+ };
+ execution.closure.computedInputs = executionInputs;
+ mockGetRemoteLiteralMap.mockResolvedValue(executionInputs);
+ values = createValuesMap(taskInputDefinitions, executionInputs);
+ });
+
+ it('passes taskId to LaunchForm', async () => {
+ const { getByText } = renderForm();
+ await waitFor(() => getByText(mockContentString));
+ checkLaunchFormProps({
+ taskId: execution.spec.launchPlan
+ });
+ });
+
+ it('maps execution input values to workflow inputs', async () => {
+ const { getByText } = renderForm();
+ await waitFor(() => getByText(mockContentString));
+
+ checkLaunchFormProps({
+ initialParameters: expect.objectContaining({
+ values
+ })
+ });
+ });
+
+ it('correctly fetches remote execution inputs', async () => {
+ delete execution.closure.computedInputs;
+ const { getByText } = renderForm();
+ await waitFor(() => getByText(mockContentString));
+ expect(mockGetExecutionData).toHaveBeenCalledWith(execution.id);
+ expect(mockGetRemoteLiteralMap).toHaveBeenCalledWith(
+ executionData.inputs.url
+ );
+ checkLaunchFormProps({
+ initialParameters: expect.objectContaining({
+ values
+ })
+ });
+ });
+ });
+});
diff --git a/src/components/Executions/ExecutionDetails/utils.ts b/src/components/Executions/ExecutionDetails/utils.ts
new file mode 100644
index 000000000..8045deb3a
--- /dev/null
+++ b/src/components/Executions/ExecutionDetails/utils.ts
@@ -0,0 +1,19 @@
+import { Execution, Identifier, ResourceType } from 'models';
+import { Routes } from 'routes';
+
+export function isSingleTaskExecution(execution: Execution) {
+ return execution.spec.launchPlan.resourceType === ResourceType.TASK;
+}
+
+export function getExecutionSourceId(execution: Execution): Identifier {
+ return isSingleTaskExecution(execution)
+ ? execution.spec.launchPlan
+ : execution.closure.workflowId;
+}
+
+export function getExecutionBackLink(execution: Execution): string {
+ const { project, domain, name } = getExecutionSourceId(execution);
+ return isSingleTaskExecution(execution)
+ ? Routes.TaskDetails.makeUrl(project, domain, name)
+ : Routes.WorkflowDetails.makeUrl(project, domain, name);
+}
diff --git a/src/components/Launch/LaunchWorkflowForm/BlobInput.tsx b/src/components/Launch/LaunchForm/BlobInput.tsx
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/BlobInput.tsx
rename to src/components/Launch/LaunchForm/BlobInput.tsx
diff --git a/src/components/Launch/LaunchWorkflowForm/CollectionInput.tsx b/src/components/Launch/LaunchForm/CollectionInput.tsx
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/CollectionInput.tsx
rename to src/components/Launch/LaunchForm/CollectionInput.tsx
diff --git a/src/components/Launch/LaunchWorkflowForm/DatetimeInput.tsx b/src/components/Launch/LaunchForm/DatetimeInput.tsx
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/DatetimeInput.tsx
rename to src/components/Launch/LaunchForm/DatetimeInput.tsx
diff --git a/src/components/Launch/LaunchForm/LaunchForm.tsx b/src/components/Launch/LaunchForm/LaunchForm.tsx
new file mode 100644
index 000000000..1f724c93e
--- /dev/null
+++ b/src/components/Launch/LaunchForm/LaunchForm.tsx
@@ -0,0 +1,30 @@
+import * as React from 'react';
+import {
+ createInputValueCache,
+ InputValueCacheContext
+} from './inputValueCache';
+import { LaunchTaskForm } from './LaunchTaskForm';
+import { LaunchWorkflowForm } from './LaunchWorkflowForm';
+import { LaunchFormProps, LaunchWorkflowFormProps } from './types';
+
+function isWorkflowPropsObject(
+ props: LaunchFormProps
+): props is LaunchWorkflowFormProps {
+ return (props as LaunchWorkflowFormProps).workflowId !== undefined;
+}
+
+/** Renders the form for initiating a Launch request based on a Workflow or Task */
+export const LaunchForm: React.FC = props => {
+ const [inputValueCache] = React.useState(createInputValueCache());
+
+ // TODO: Use LaunchTaskForm when it has been implemented.
+ return (
+
+ {isWorkflowPropsObject(props) ? (
+
+ ) : (
+
+ )}
+
+ );
+};
diff --git a/src/components/Launch/LaunchForm/LaunchFormActions.tsx b/src/components/Launch/LaunchForm/LaunchFormActions.tsx
new file mode 100644
index 000000000..c09c8ef9d
--- /dev/null
+++ b/src/components/Launch/LaunchForm/LaunchFormActions.tsx
@@ -0,0 +1,89 @@
+import { Button, DialogActions, FormHelperText } from '@material-ui/core';
+import { ButtonCircularProgress } from 'components';
+import * as React from 'react';
+import { history } from 'routes/history';
+import { Routes } from 'routes/routes';
+import { formStrings } from './constants';
+import { LaunchState } from './launchMachine';
+import { useStyles } from './styles';
+import { BaseInterpretedLaunchState, BaseLaunchService } from './types';
+
+export interface LaunchFormActionsProps {
+ state: BaseInterpretedLaunchState;
+ service: BaseLaunchService;
+ onClose(): void;
+}
+/** Renders the Submit/Cancel buttons for a LaunchForm */
+export const LaunchFormActions: React.FC = ({
+ state,
+ service,
+ onClose
+}) => {
+ const styles = useStyles();
+ const submissionInFlight = state.matches(LaunchState.SUBMITTING);
+ const canSubmit = [
+ LaunchState.ENTER_INPUTS,
+ LaunchState.VALIDATING_INPUTS,
+ LaunchState.INVALID_INPUTS,
+ LaunchState.SUBMIT_FAILED
+ ].some(state.matches);
+
+ const submit: React.FormEventHandler = event => {
+ event.preventDefault();
+ service.send({ type: 'SUBMIT' });
+ };
+
+ const onCancel = () => {
+ service.send({ type: 'CANCEL' });
+ onClose();
+ };
+
+ React.useEffect(() => {
+ const subscription = service.subscribe(newState => {
+ // On transition to final success state, read the resulting execution
+ // id and navigate to the Execution Details page.
+ // if (state.matches({ submit: 'succeeded' })) {
+ if (newState.matches(LaunchState.SUBMIT_SUCCEEDED)) {
+ history.push(
+ Routes.ExecutionDetails.makeUrl(
+ newState.context.resultExecutionId
+ )
+ );
+ }
+ });
+
+ return subscription.unsubscribe;
+ }, [service]);
+
+ return (
+
+ {state.matches(LaunchState.SUBMIT_FAILED) ? (
+
+ {state.context.error.message}
+
+ ) : null}
+
+
+
+
+
+ );
+};
diff --git a/src/components/Launch/LaunchForm/LaunchFormHeader.tsx b/src/components/Launch/LaunchForm/LaunchFormHeader.tsx
new file mode 100644
index 000000000..38aa12a96
--- /dev/null
+++ b/src/components/Launch/LaunchForm/LaunchFormHeader.tsx
@@ -0,0 +1,17 @@
+import { DialogTitle, Typography } from '@material-ui/core';
+import * as React from 'react';
+import { formStrings } from './constants';
+import { useStyles } from './styles';
+
+/** Shared header component for the Launch form */
+export const LaunchFormHeader: React.FC<{ title?: string }> = ({
+ title = ''
+}) => {
+ const styles = useStyles();
+ return (
+
+ {formStrings.title}
+ {title}
+
+ );
+};
diff --git a/src/components/Launch/LaunchForm/LaunchFormInputs.tsx b/src/components/Launch/LaunchForm/LaunchFormInputs.tsx
new file mode 100644
index 000000000..01ae9adb5
--- /dev/null
+++ b/src/components/Launch/LaunchForm/LaunchFormInputs.tsx
@@ -0,0 +1,91 @@
+import * as React from 'react';
+import { BlobInput } from './BlobInput';
+import { CollectionInput } from './CollectionInput';
+import { formStrings } from './constants';
+import { LaunchState } from './launchMachine';
+import { SimpleInput } from './SimpleInput';
+import { useStyles } from './styles';
+import {
+ BaseInterpretedLaunchState,
+ InputProps,
+ InputType,
+ LaunchFormInputsRef
+} from './types';
+import { UnsupportedInput } from './UnsupportedInput';
+import { UnsupportedRequiredInputsError } from './UnsupportedRequiredInputsError';
+import { useFormInputsState } from './useFormInputsState';
+
+function getComponentForInput(input: InputProps, showErrors: boolean) {
+ const props = { ...input, error: showErrors ? input.error : undefined };
+ switch (input.typeDefinition.type) {
+ case InputType.Blob:
+ return ;
+ case InputType.Collection:
+ return ;
+ case InputType.Map:
+ case InputType.Schema:
+ case InputType.Unknown:
+ case InputType.None:
+ return ;
+ default:
+ return ;
+ }
+}
+
+export interface LaunchFormInputsProps {
+ state: BaseInterpretedLaunchState;
+ variant: 'workflow' | 'task';
+}
+
+export const LaunchFormInputsImpl: React.RefForwardingComponent<
+ LaunchFormInputsRef,
+ LaunchFormInputsProps
+> = ({ state, variant }, ref) => {
+ const {
+ parsedInputs,
+ unsupportedRequiredInputs,
+ showErrors
+ } = state.context;
+ const { getValues, inputs, validate } = useFormInputsState(parsedInputs);
+ const styles = useStyles();
+ React.useImperativeHandle(ref, () => ({
+ getValues,
+ validate
+ }));
+
+ const showInputs = [
+ LaunchState.UNSUPPORTED_INPUTS,
+ LaunchState.ENTER_INPUTS,
+ LaunchState.VALIDATING_INPUTS,
+ LaunchState.INVALID_INPUTS,
+ LaunchState.SUBMIT_VALIDATING,
+ LaunchState.SUBMITTING,
+ LaunchState.SUBMIT_FAILED,
+ LaunchState.SUBMIT_SUCCEEDED
+ ].some(state.matches);
+
+ return showInputs ? (
+
+ {state.matches(LaunchState.UNSUPPORTED_INPUTS) ? (
+
+ ) : (
+ <>
+ {inputs.map(input => (
+
+ {getComponentForInput(input, showErrors)}
+
+ ))}
+
+ )}
+
+ ) : null;
+};
+
+/** Renders an array of `ParsedInput` values using the appropriate
+ * components. A `ref` to this component is used to access the current
+ * form values and trigger manual validation if needed.
+ */
+export const LaunchFormInputs = React.forwardRef(LaunchFormInputsImpl);
diff --git a/src/components/Launch/LaunchForm/LaunchTaskForm.tsx b/src/components/Launch/LaunchForm/LaunchTaskForm.tsx
new file mode 100644
index 000000000..12f52dd7d
--- /dev/null
+++ b/src/components/Launch/LaunchForm/LaunchTaskForm.tsx
@@ -0,0 +1,83 @@
+import { DialogContent } from '@material-ui/core';
+import { getCacheKey } from 'components/Cache/utils';
+import * as React from 'react';
+import { formStrings } from './constants';
+import { LaunchFormActions } from './LaunchFormActions';
+import { LaunchFormHeader } from './LaunchFormHeader';
+import { LaunchFormInputs } from './LaunchFormInputs';
+import { LaunchState } from './launchMachine';
+import { SearchableSelector } from './SearchableSelector';
+import { useStyles } from './styles';
+import {
+ BaseInterpretedLaunchState,
+ BaseLaunchService,
+ LaunchTaskFormProps
+} from './types';
+import { useLaunchTaskFormState } from './useLaunchTaskFormState';
+
+/** Renders the form for initiating a Launch request based on a Task */
+export const LaunchTaskForm: React.FC = props => {
+ const {
+ formInputsRef,
+ state,
+ service,
+ taskSourceSelectorState
+ } = useLaunchTaskFormState(props);
+ const styles = useStyles();
+ const baseState = state as BaseInterpretedLaunchState;
+ const baseService = service as BaseLaunchService;
+
+ // Any time the inputs change (even if it's just re-ordering), we must
+ // change the form key so that the inputs component will re-mount.
+ const formKey = React.useMemo(() => {
+ return getCacheKey(state.context.parsedInputs);
+ }, [state.context.parsedInputs]);
+
+ const {
+ fetchSearchResults,
+ onSelectTaskVersion,
+ selectedTask,
+ taskSelectorOptions
+ } = taskSourceSelectorState;
+
+ const showTaskSelector = ![
+ LaunchState.LOADING_TASK_VERSIONS,
+ LaunchState.FAILED_LOADING_TASK_VERSIONS
+ ].some(state.matches);
+
+ // TODO: We removed all loading indicators here. Decide if we want skeletons
+ // instead.
+ return (
+ <>
+
+
+ {showTaskSelector ? (
+
+ ) : null}
+
+
+
+
+ );
+};
diff --git a/src/components/Launch/LaunchForm/LaunchWorkflowForm.tsx b/src/components/Launch/LaunchForm/LaunchWorkflowForm.tsx
new file mode 100644
index 000000000..fffe4d7ae
--- /dev/null
+++ b/src/components/Launch/LaunchForm/LaunchWorkflowForm.tsx
@@ -0,0 +1,106 @@
+import { DialogContent } from '@material-ui/core';
+import { getCacheKey } from 'components/Cache/utils';
+import * as React from 'react';
+import { formStrings } from './constants';
+import { LaunchFormActions } from './LaunchFormActions';
+import { LaunchFormHeader } from './LaunchFormHeader';
+import { LaunchFormInputs } from './LaunchFormInputs';
+import { LaunchState } from './launchMachine';
+import { SearchableSelector } from './SearchableSelector';
+import { useStyles } from './styles';
+import {
+ BaseInterpretedLaunchState,
+ BaseLaunchService,
+ LaunchWorkflowFormProps
+} from './types';
+import { useLaunchWorkflowFormState } from './useLaunchWorkflowFormState';
+
+/** Renders the form for initiating a Launch request based on a Workflow */
+export const LaunchWorkflowForm: React.FC = props => {
+ const {
+ formInputsRef,
+ state,
+ service,
+ workflowSourceSelectorState
+ } = useLaunchWorkflowFormState(props);
+ const styles = useStyles();
+ const baseState = state as BaseInterpretedLaunchState;
+ const baseService = service as BaseLaunchService;
+
+ // Any time the inputs change (even if it's just re-ordering), we must
+ // change the form key so that the inputs component will re-mount.
+ const formKey = React.useMemo(() => {
+ return getCacheKey(state.context.parsedInputs);
+ }, [state.context.parsedInputs]);
+
+ const {
+ fetchSearchResults,
+ launchPlanSelectorOptions,
+ onSelectLaunchPlan,
+ onSelectWorkflowVersion,
+ selectedLaunchPlan,
+ selectedWorkflow,
+ workflowSelectorOptions
+ } = workflowSourceSelectorState;
+
+ const showWorkflowSelector = ![
+ LaunchState.LOADING_WORKFLOW_VERSIONS,
+ LaunchState.FAILED_LOADING_WORKFLOW_VERSIONS
+ ].some(state.matches);
+ const showLaunchPlanSelector =
+ state.context.workflowVersion &&
+ ![
+ LaunchState.LOADING_LAUNCH_PLANS,
+ LaunchState.FAILED_LOADING_LAUNCH_PLANS
+ ].some(state.matches);
+
+ // TODO: We removed all loading indicators here. Decide if we want skeletons
+ // instead.
+ return (
+ <>
+
+
+ {showWorkflowSelector ? (
+
+ ) : null}
+ {showLaunchPlanSelector ? (
+
+ ) : null}
+
+
+
+
+ );
+};
diff --git a/src/components/Launch/LaunchWorkflowForm/SearchableSelector.tsx b/src/components/Launch/LaunchForm/SearchableSelector.tsx
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/SearchableSelector.tsx
rename to src/components/Launch/LaunchForm/SearchableSelector.tsx
diff --git a/src/components/Launch/LaunchWorkflowForm/SimpleInput.tsx b/src/components/Launch/LaunchForm/SimpleInput.tsx
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/SimpleInput.tsx
rename to src/components/Launch/LaunchForm/SimpleInput.tsx
diff --git a/src/components/Launch/LaunchWorkflowForm/UnsupportedInput.tsx b/src/components/Launch/LaunchForm/UnsupportedInput.tsx
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/UnsupportedInput.tsx
rename to src/components/Launch/LaunchForm/UnsupportedInput.tsx
diff --git a/src/components/Launch/LaunchWorkflowForm/UnsupportedRequiredInputsError.tsx b/src/components/Launch/LaunchForm/UnsupportedRequiredInputsError.tsx
similarity index 77%
rename from src/components/Launch/LaunchWorkflowForm/UnsupportedRequiredInputsError.tsx
rename to src/components/Launch/LaunchForm/UnsupportedRequiredInputsError.tsx
index 6d31b61d0..34d989253 100644
--- a/src/components/Launch/LaunchWorkflowForm/UnsupportedRequiredInputsError.tsx
+++ b/src/components/Launch/LaunchForm/UnsupportedRequiredInputsError.tsx
@@ -4,9 +4,11 @@ import { NonIdealState } from 'components/common';
import { useCommonStyles } from 'components/common/styles';
import * as React from 'react';
import {
+ cannotLaunchTaskString,
cannotLaunchWorkflowString,
requiredInputSuffix,
- unsupportedRequiredInputsString
+ taskUnsupportedRequiredInputsString,
+ workflowUnsupportedRequiredInputsString
} from './constants';
import { ParsedInput } from './types';
@@ -28,24 +30,33 @@ function formatLabel(label: string) {
export interface UnsupportedRequiredInputsErrorProps {
inputs: ParsedInput[];
+ variant: 'workflow' | 'task';
}
/** An informational error to be shown if a Workflow cannot be launch due to
* required inputs for which we will not be able to provide a value.
*/
export const UnsupportedRequiredInputsError: React.FC = ({
- inputs
+ inputs,
+ variant
}) => {
const styles = useStyles();
const commonStyles = useCommonStyles();
+ const [titleString, errorString] =
+ variant === 'workflow'
+ ? [
+ cannotLaunchWorkflowString,
+ workflowUnsupportedRequiredInputsString
+ ]
+ : [cannotLaunchTaskString, taskUnsupportedRequiredInputsString];
return (
-
{unsupportedRequiredInputsString}
+
{errorString}
{inputs.map(input => (
-
): TypedInterface {
return {
diff --git a/src/components/Launch/LaunchWorkflowForm/__mocks__/utils.ts b/src/components/Launch/LaunchForm/__mocks__/utils.ts
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/__mocks__/utils.ts
rename to src/components/Launch/LaunchForm/__mocks__/utils.ts
diff --git a/src/components/Launch/LaunchWorkflowForm/__stories__/LaunchWorkflowForm.stories.tsx b/src/components/Launch/LaunchForm/__stories__/LaunchForm.stories.tsx
similarity index 88%
rename from src/components/Launch/LaunchWorkflowForm/__stories__/LaunchWorkflowForm.stories.tsx
rename to src/components/Launch/LaunchForm/__stories__/LaunchForm.stories.tsx
index d7497d34b..658a8eae3 100644
--- a/src/components/Launch/LaunchWorkflowForm/__stories__/LaunchWorkflowForm.stories.tsx
+++ b/src/components/Launch/LaunchForm/__stories__/LaunchForm.stories.tsx
@@ -23,16 +23,17 @@ import {
import { mockWorkflowExecutionResponse } from 'models/Execution/__mocks__/mockWorkflowExecutionsData';
import * as React from 'react';
import {
- createMockWorkflowInputsInterface,
+ createMockInputsInterface,
mockCollectionVariables,
mockNestedCollectionVariables,
mockSimpleVariables,
simpleVariableDefaults,
SimpleVariableKey
} from '../__mocks__/mockInputs';
-import { LaunchWorkflowForm } from '../LaunchWorkflowForm';
+import { LaunchForm } from '../LaunchForm';
import { binaryInputName, errorInputName } from '../test/constants';
-import { useExecutionLaunchConfiguration } from '../useExecutionLaunchConfiguration';
+import { WorkflowInitialLaunchParameters } from '../types';
+import { useMappedExecutionInputValues } from '../useMappedExecutionInputValues';
import { getWorkflowInputs } from '../utils';
const booleanInputName = 'simpleBoolean';
@@ -44,7 +45,7 @@ const submitAction = action('createWorkflowExecution');
const generateMocks = (variables: Record) => {
const mockWorkflow = createMockWorkflow('MyWorkflow');
mockWorkflow.closure = createMockWorkflowClosure();
- mockWorkflow.closure!.compiledWorkflow!.primary.template.interface = createMockWorkflowInputsInterface(
+ mockWorkflow.closure!.compiledWorkflow!.primary.template.interface = createMockInputsInterface(
variables
);
@@ -95,7 +96,7 @@ const generateMocks = (variables: Record) => {
id
};
workflow.closure = createMockWorkflowClosure();
- workflow.closure!.compiledWorkflow!.primary.template.interface = createMockWorkflowInputsInterface(
+ workflow.closure!.compiledWorkflow!.primary.template.interface = createMockInputsInterface(
variables
);
@@ -117,17 +118,26 @@ interface RenderFormArgs {
const LaunchFormWithExecution: React.FC = ({ execution, mocks: { mockWorkflow } }) => {
- const launchConfig = useExecutionLaunchConfiguration({
+ const {
+ closure: { workflowId },
+ spec: { launchPlan }
+ } = execution;
+ const executionInputs = useMappedExecutionInputValues({
execution,
- workflowInputs: getWorkflowInputs(mockWorkflow)
+ inputDefinitions: getWorkflowInputs(mockWorkflow)
});
+ const initialParameters: WorkflowInitialLaunchParameters = {
+ workflowId,
+ launchPlan,
+ values: executionInputs.value
+ };
const onClose = () => console.log('Close');
return (
-
-
+
);
@@ -148,7 +158,7 @@ const renderForm = (args: RenderFormArgs) => {
execution={args.execution}
/>
) : (
-
@@ -158,7 +168,7 @@ const renderForm = (args: RenderFormArgs) => {
);
};
-const stories = storiesOf('Launch/LaunchWorkflowForm', module);
+const stories = storiesOf('Launch/LaunchForm/Workflow', module);
stories.add('Simple', () =>
renderForm({ mocks: generateMocks(mockSimpleVariables) })
diff --git a/src/components/Launch/LaunchWorkflowForm/__stories__/WorkflowSelector.stories.tsx b/src/components/Launch/LaunchForm/__stories__/WorkflowSelector.stories.tsx
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/__stories__/WorkflowSelector.stories.tsx
rename to src/components/Launch/LaunchForm/__stories__/WorkflowSelector.stories.tsx
diff --git a/src/components/Launch/LaunchWorkflowForm/constants.ts b/src/components/Launch/LaunchForm/constants.ts
similarity index 74%
rename from src/components/Launch/LaunchWorkflowForm/constants.ts
rename to src/components/Launch/LaunchForm/constants.ts
index c873f7ab2..31f18c1e4 100644
--- a/src/components/Launch/LaunchWorkflowForm/constants.ts
+++ b/src/components/Launch/LaunchForm/constants.ts
@@ -17,7 +17,8 @@ export const formStrings = {
cancel: 'Cancel',
inputs: 'Inputs',
submit: 'Launch',
- title: 'Launch Workflow',
+ taskVersion: 'Task Version',
+ title: 'Create New Execution',
workflowVersion: 'Workflow Version',
launchPlan: 'Launch Plan'
};
@@ -62,6 +63,8 @@ export const defaultBlobValue: BlobValue = {
export const requiredInputSuffix = '*';
export const cannotLaunchWorkflowString = 'Workflow cannot be launched';
-export const unsupportedRequiredInputsString = `This Workflow version contains one or more required inputs which are not supported by Flyte Console and do not have default values specified in the Workflow definition or the selected Launch Plan.\n\nYou can launch this Workflow version with the Flyte CLI or by selecting a Launch Plan which provides values for the unsupported inputs.\n\nThe required inputs are :`;
+export const cannotLaunchTaskString = 'Task cannot be launched';
+export const workflowUnsupportedRequiredInputsString = `This Workflow version contains one or more required inputs which are not supported by Flyte Console and do not have default values specified in the Workflow definition or the selected Launch Plan.\n\nYou can launch this Workflow version with the Flyte CLI or by selecting a Launch Plan which provides values for the unsupported inputs.\n\nThe required inputs are :`;
+export const taskUnsupportedRequiredInputsString = `This Task version contains one or more required inputs which are not supported by Flyte Console.\n\nYou can launch this Task version with the Flyte CLI instead.\n\nThe required inputs are :`;
export const blobUriHelperText = '(required) location of the data';
export const blobFormatHelperText = '(optional) csv, parquet, etc...';
diff --git a/src/components/Launch/LaunchWorkflowForm/getInputs.ts b/src/components/Launch/LaunchForm/getInputs.ts
similarity index 62%
rename from src/components/Launch/LaunchWorkflowForm/getInputs.ts
rename to src/components/Launch/LaunchForm/getInputs.ts
index 63dd7c754..16b233265 100644
--- a/src/components/Launch/LaunchWorkflowForm/getInputs.ts
+++ b/src/components/Launch/LaunchForm/getInputs.ts
@@ -1,11 +1,12 @@
import { sortedObjectEntries } from 'common/utils';
-import { LaunchPlan, Workflow } from 'models';
+import { LaunchPlan, Task, Workflow } from 'models';
import { requiredInputSuffix } from './constants';
import { LiteralValueMap, ParsedInput } from './types';
import {
createInputCacheKey,
formatLabelWithType,
getInputDefintionForLiteralType,
+ getTaskInputs,
getWorkflowInputs
} from './utils';
@@ -13,7 +14,7 @@ import {
// to depend on the existence of a value
const emptyDescription = ' ';
-export function getInputs(
+export function getInputsForWorkflow(
workflow: Workflow,
launchPlan: LaunchPlan,
initialValues: LiteralValueMap = new Map()
@@ -57,3 +58,35 @@ export function getInputs(
};
});
}
+
+export function getInputsForTask(
+ task: Task,
+ initialValues: LiteralValueMap = new Map()
+): ParsedInput[] {
+ if (!task) {
+ return [];
+ }
+
+ const taskInputs = getTaskInputs(task);
+ return sortedObjectEntries(taskInputs).map(value => {
+ const [name, { description = emptyDescription, type }] = value;
+ const typeDefinition = getInputDefintionForLiteralType(type);
+ const typeLabel = formatLabelWithType(name, typeDefinition);
+ const label = `${typeLabel}${requiredInputSuffix}`;
+ const inputKey = createInputCacheKey(name, typeDefinition);
+ const initialValue = initialValues.has(inputKey)
+ ? initialValues.get(inputKey)
+ : undefined;
+
+ return {
+ description,
+ initialValue,
+ label,
+ name,
+ typeDefinition,
+ // Task inputs are always required, as there is no default provided
+ // by a parent workflow.
+ required: true
+ };
+ });
+}
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/blob.ts b/src/components/Launch/LaunchForm/inputHelpers/blob.ts
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/inputHelpers/blob.ts
rename to src/components/Launch/LaunchForm/inputHelpers/blob.ts
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/boolean.ts b/src/components/Launch/LaunchForm/inputHelpers/boolean.ts
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/inputHelpers/boolean.ts
rename to src/components/Launch/LaunchForm/inputHelpers/boolean.ts
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/collection.ts b/src/components/Launch/LaunchForm/inputHelpers/collection.ts
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/inputHelpers/collection.ts
rename to src/components/Launch/LaunchForm/inputHelpers/collection.ts
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/constants.ts b/src/components/Launch/LaunchForm/inputHelpers/constants.ts
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/inputHelpers/constants.ts
rename to src/components/Launch/LaunchForm/inputHelpers/constants.ts
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/datetime.ts b/src/components/Launch/LaunchForm/inputHelpers/datetime.ts
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/inputHelpers/datetime.ts
rename to src/components/Launch/LaunchForm/inputHelpers/datetime.ts
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/duration.ts b/src/components/Launch/LaunchForm/inputHelpers/duration.ts
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/inputHelpers/duration.ts
rename to src/components/Launch/LaunchForm/inputHelpers/duration.ts
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/float.ts b/src/components/Launch/LaunchForm/inputHelpers/float.ts
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/inputHelpers/float.ts
rename to src/components/Launch/LaunchForm/inputHelpers/float.ts
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/getHelperForInput.ts b/src/components/Launch/LaunchForm/inputHelpers/getHelperForInput.ts
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/inputHelpers/getHelperForInput.ts
rename to src/components/Launch/LaunchForm/inputHelpers/getHelperForInput.ts
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/inputHelpers.ts b/src/components/Launch/LaunchForm/inputHelpers/inputHelpers.ts
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/inputHelpers/inputHelpers.ts
rename to src/components/Launch/LaunchForm/inputHelpers/inputHelpers.ts
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/integer.ts b/src/components/Launch/LaunchForm/inputHelpers/integer.ts
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/inputHelpers/integer.ts
rename to src/components/Launch/LaunchForm/inputHelpers/integer.ts
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/none.ts b/src/components/Launch/LaunchForm/inputHelpers/none.ts
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/inputHelpers/none.ts
rename to src/components/Launch/LaunchForm/inputHelpers/none.ts
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/parseJson.ts b/src/components/Launch/LaunchForm/inputHelpers/parseJson.ts
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/inputHelpers/parseJson.ts
rename to src/components/Launch/LaunchForm/inputHelpers/parseJson.ts
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/string.ts b/src/components/Launch/LaunchForm/inputHelpers/string.ts
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/inputHelpers/string.ts
rename to src/components/Launch/LaunchForm/inputHelpers/string.ts
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/test/inputHelpers.test.ts b/src/components/Launch/LaunchForm/inputHelpers/test/inputHelpers.test.ts
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/inputHelpers/test/inputHelpers.test.ts
rename to src/components/Launch/LaunchForm/inputHelpers/test/inputHelpers.test.ts
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/test/testCases.ts b/src/components/Launch/LaunchForm/inputHelpers/test/testCases.ts
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/inputHelpers/test/testCases.ts
rename to src/components/Launch/LaunchForm/inputHelpers/test/testCases.ts
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/test/utils.test.ts b/src/components/Launch/LaunchForm/inputHelpers/test/utils.test.ts
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/inputHelpers/test/utils.test.ts
rename to src/components/Launch/LaunchForm/inputHelpers/test/utils.test.ts
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/types.ts b/src/components/Launch/LaunchForm/inputHelpers/types.ts
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/inputHelpers/types.ts
rename to src/components/Launch/LaunchForm/inputHelpers/types.ts
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/utils.ts b/src/components/Launch/LaunchForm/inputHelpers/utils.ts
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/inputHelpers/utils.ts
rename to src/components/Launch/LaunchForm/inputHelpers/utils.ts
diff --git a/src/components/Launch/LaunchWorkflowForm/inputValueCache.ts b/src/components/Launch/LaunchForm/inputValueCache.ts
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/inputValueCache.ts
rename to src/components/Launch/LaunchForm/inputValueCache.ts
diff --git a/src/components/Launch/LaunchForm/launchMachine.ts b/src/components/Launch/LaunchForm/launchMachine.ts
new file mode 100644
index 000000000..317ca783a
--- /dev/null
+++ b/src/components/Launch/LaunchForm/launchMachine.ts
@@ -0,0 +1,517 @@
+import {
+ Identifier,
+ LaunchPlan,
+ NamedEntityIdentifier,
+ Task,
+ Workflow,
+ WorkflowExecutionIdentifier,
+ WorkflowId
+} from 'models';
+import {
+ assign,
+ DoneInvokeEvent,
+ Machine,
+ MachineConfig,
+ MachineOptions,
+ StatesConfig
+} from 'xstate';
+import { LiteralValueMap, ParsedInput } from './types';
+
+export type SelectWorkflowVersionEvent = {
+ type: 'SELECT_WORKFLOW_VERSION';
+ workflowId: WorkflowId;
+};
+export type SelectTaskVersionEvent = {
+ type: 'SELECT_TASK_VERSION';
+ taskId: Identifier;
+};
+export type SelectLaunchPlanEvent = {
+ type: 'SELECT_LAUNCH_PLAN';
+ launchPlan: LaunchPlan;
+};
+export type WorkflowVersionOptionsLoadedEvent = DoneInvokeEvent;
+export type LaunchPlanOptionsLoadedEvent = DoneInvokeEvent;
+export type TaskVersionOptionsLoadedEvent = DoneInvokeEvent;
+export type ExecutionCreatedEvent = DoneInvokeEvent<
+ WorkflowExecutionIdentifier
+>;
+export type InputsParsedEvent = DoneInvokeEvent<{
+ parsedInputs: ParsedInput[];
+ unsupportedRequiredInputs?: ParsedInput[];
+}>;
+export type ErrorEvent = DoneInvokeEvent;
+
+export type BaseLaunchEvent =
+ | { type: 'CANCEL' }
+ | { type: 'SUBMIT' }
+ | { type: 'RETRY' }
+ | InputsParsedEvent
+ | SelectTaskVersionEvent
+ | SelectLaunchPlanEvent
+ | ExecutionCreatedEvent
+ | ErrorEvent;
+
+export type TaskLaunchEvent =
+ | BaseLaunchEvent
+ | TaskVersionOptionsLoadedEvent
+ | SelectTaskVersionEvent;
+
+export type WorkflowLaunchEvent =
+ | BaseLaunchEvent
+ | SelectWorkflowVersionEvent
+ | WorkflowVersionOptionsLoadedEvent
+ | LaunchPlanOptionsLoadedEvent;
+
+export interface BaseLaunchContext {
+ defaultInputValues?: LiteralValueMap;
+ parsedInputs: ParsedInput[];
+ resultExecutionId?: WorkflowExecutionIdentifier;
+ sourceId?: NamedEntityIdentifier;
+ error?: Error;
+ showErrors: boolean;
+ referenceExecutionId?: WorkflowExecutionIdentifier;
+ unsupportedRequiredInputs: ParsedInput[];
+}
+
+export interface WorkflowLaunchContext extends BaseLaunchContext {
+ launchPlan?: LaunchPlan;
+ launchPlanOptions?: LaunchPlan[];
+ preferredLaunchPlanId?: Identifier;
+ preferredWorkflowId?: Identifier;
+ workflowVersion?: WorkflowId;
+ workflowVersionOptions?: Workflow[];
+}
+
+export interface TaskLaunchContext extends BaseLaunchContext {
+ preferredTaskId?: Identifier;
+ taskVersion?: Identifier;
+ taskVersionOptions?: Task[];
+}
+
+export enum LaunchState {
+ CANCELLED = 'CANCELLED',
+ SELECT_SOURCE = 'SELECT_SOURCE',
+ LOADING_WORKFLOW_VERSIONS = 'LOADING_WORKFLOW_VERSIONS',
+ FAILED_LOADING_WORKFLOW_VERSIONS = 'FAILED_LOADING_WORKFLOW_VERSIONS',
+ SELECT_WORKFLOW_VERSION = 'SELECT_WORKFLOW_VERSION',
+ LOADING_LAUNCH_PLANS = 'LOADING_LAUNCH_PLANS',
+ FAILED_LOADING_LAUNCH_PLANS = 'FAILED_LOADING_LAUNCH_PLANS',
+ SELECT_LAUNCH_PLAN = 'SELECT_LAUNCH_PLAN',
+ LOADING_TASK_VERSIONS = 'LOADING_TASK_VERSIONS',
+ FAILED_LOADING_TASK_VERSIONS = 'FAILED_LOADING_TASK_VERSIONS',
+ SELECT_TASK_VERSION = 'SELECT_TASK_VERSION',
+ LOADING_INPUTS = 'LOADING_INPUTS',
+ FAILED_LOADING_INPUTS = 'FAILED_LOADING_INPUTS',
+ UNSUPPORTED_INPUTS = 'UNSUPPORTED_INPUTS',
+ ENTER_INPUTS = 'ENTER_INPUTS',
+ VALIDATING_INPUTS = 'VALIDATING_INPUTS',
+ INVALID_INPUTS = 'INVALID_INPUTS',
+ SUBMIT_VALIDATING = 'SUBMIT_VALIDATING',
+ SUBMITTING = 'SUBMITTING',
+ SUBMIT_FAILED = 'SUBMIT_FAILED',
+ SUBMIT_SUCCEEDED = 'SUBMIT_SUCCEEDED'
+}
+
+interface BaseLaunchSchema {
+ states: {
+ [LaunchState.CANCELLED]: {};
+ [LaunchState.LOADING_INPUTS]: {};
+ [LaunchState.FAILED_LOADING_INPUTS]: {};
+ [LaunchState.UNSUPPORTED_INPUTS]: {};
+ [LaunchState.ENTER_INPUTS]: {};
+ [LaunchState.VALIDATING_INPUTS]: {};
+ [LaunchState.INVALID_INPUTS]: {};
+ [LaunchState.SUBMIT_VALIDATING]: {};
+ [LaunchState.SUBMITTING]: {};
+ [LaunchState.SUBMIT_FAILED]: {};
+ [LaunchState.SUBMIT_SUCCEEDED]: {};
+ };
+}
+
+interface TaskLaunchSchema extends BaseLaunchSchema {
+ states: BaseLaunchSchema['states'] & {
+ [LaunchState.LOADING_TASK_VERSIONS]: {};
+ [LaunchState.FAILED_LOADING_TASK_VERSIONS]: {};
+ [LaunchState.SELECT_TASK_VERSION]: {};
+ };
+}
+interface WorkflowLaunchSchema extends BaseLaunchSchema {
+ states: BaseLaunchSchema['states'] & {
+ [LaunchState.LOADING_WORKFLOW_VERSIONS]: {};
+ [LaunchState.FAILED_LOADING_WORKFLOW_VERSIONS]: {};
+ [LaunchState.SELECT_WORKFLOW_VERSION]: {};
+ [LaunchState.LOADING_LAUNCH_PLANS]: {};
+ [LaunchState.FAILED_LOADING_LAUNCH_PLANS]: {};
+ [LaunchState.SELECT_LAUNCH_PLAN]: {};
+ };
+}
+
+/** Typestates to narrow down the `context` values based on the result of
+ * a `state.matches` check.
+ */
+export type BaseLaunchTypestate =
+ | {
+ value: LaunchState;
+ context: BaseLaunchContext;
+ }
+ | {
+ value: LaunchState.UNSUPPORTED_INPUTS;
+ context: BaseLaunchContext & {
+ parsedInputs: [];
+ unsupportedRequiredInputs: [];
+ };
+ }
+ | {
+ value:
+ | LaunchState.ENTER_INPUTS
+ | LaunchState.VALIDATING_INPUTS
+ | LaunchState.INVALID_INPUTS
+ | LaunchState.SUBMIT_VALIDATING
+ | LaunchState.SUBMITTING
+ | LaunchState.SUBMIT_SUCCEEDED;
+ context: BaseLaunchContext & {
+ parsedInputs: [];
+ };
+ }
+ | {
+ value: LaunchState.SUBMIT_SUCCEEDED;
+ context: BaseLaunchContext & {
+ resultExecutionId: WorkflowExecutionIdentifier;
+ };
+ }
+ | {
+ value: LaunchState.SUBMIT_FAILED;
+ context: BaseLaunchContext & {
+ parsedInputs: ParsedInput[];
+ error: Error;
+ };
+ }
+ | {
+ value:
+ | LaunchState.FAILED_LOADING_INPUTS
+ | LaunchState.FAILED_LOADING_LAUNCH_PLANS
+ | LaunchState.FAILED_LOADING_TASK_VERSIONS
+ | LaunchState.FAILED_LOADING_WORKFLOW_VERSIONS;
+ context: BaseLaunchContext & {
+ error: Error;
+ };
+ };
+
+export type WorkflowLaunchTypestate =
+ | BaseLaunchTypestate
+ | {
+ value: LaunchState.SELECT_WORKFLOW_VERSION;
+ context: WorkflowLaunchContext & {
+ sourceId: NamedEntityIdentifier;
+ workflowVersionOptions: Workflow[];
+ };
+ }
+ | {
+ value: LaunchState.SELECT_LAUNCH_PLAN;
+ context: WorkflowLaunchContext & {
+ launchPlanOptions: LaunchPlan[];
+ sourceId: NamedEntityIdentifier;
+ workflowVersionOptions: Workflow[];
+ };
+ };
+
+export type TaskLaunchTypestate =
+ | BaseLaunchTypestate
+ | {
+ value: LaunchState.SELECT_TASK_VERSION;
+ context: TaskLaunchContext & {
+ sourceId: NamedEntityIdentifier;
+ taskVersionOptions: Task[];
+ };
+ };
+
+const defaultBaseContext: BaseLaunchContext = {
+ parsedInputs: [],
+ showErrors: false,
+ unsupportedRequiredInputs: []
+};
+
+const defaultHandlers = {
+ CANCEL: LaunchState.CANCELLED
+};
+
+const baseStateConfig: StatesConfig<
+ BaseLaunchContext,
+ BaseLaunchSchema,
+ BaseLaunchEvent
+> = {
+ [LaunchState.CANCELLED]: {
+ type: 'final'
+ },
+ [LaunchState.LOADING_INPUTS]: {
+ entry: ['hideErrors'],
+ invoke: {
+ src: 'loadInputs',
+ onDone: {
+ target: LaunchState.ENTER_INPUTS,
+ actions: ['setInputs']
+ },
+ onError: {
+ target: LaunchState.FAILED_LOADING_INPUTS,
+ actions: ['setError']
+ }
+ }
+ },
+ [LaunchState.FAILED_LOADING_INPUTS]: {
+ on: {
+ RETRY: LaunchState.LOADING_INPUTS
+ }
+ },
+ [LaunchState.UNSUPPORTED_INPUTS]: {
+ // events handled at top level
+ },
+ [LaunchState.ENTER_INPUTS]: {
+ always: {
+ target: LaunchState.UNSUPPORTED_INPUTS,
+ cond: ({ unsupportedRequiredInputs }) =>
+ unsupportedRequiredInputs.length > 0
+ },
+ on: {
+ SUBMIT: LaunchState.SUBMIT_VALIDATING,
+ VALIDATE: LaunchState.VALIDATING_INPUTS
+ }
+ },
+ [LaunchState.VALIDATING_INPUTS]: {
+ invoke: {
+ src: 'validate',
+ onDone: LaunchState.ENTER_INPUTS,
+ onError: LaunchState.INVALID_INPUTS
+ }
+ },
+ [LaunchState.INVALID_INPUTS]: {
+ on: {
+ VALIDATE: LaunchState.VALIDATING_INPUTS
+ }
+ },
+ [LaunchState.SUBMIT_VALIDATING]: {
+ entry: ['showErrors'],
+ invoke: {
+ src: 'validate',
+ onDone: {
+ target: LaunchState.SUBMITTING
+ },
+ onError: {
+ target: LaunchState.INVALID_INPUTS,
+ actions: ['setError']
+ }
+ }
+ },
+ [LaunchState.SUBMITTING]: {
+ invoke: {
+ src: 'submit',
+ onDone: {
+ target: LaunchState.SUBMIT_SUCCEEDED,
+ actions: ['setExecutionId']
+ },
+ onError: {
+ target: LaunchState.SUBMIT_FAILED,
+ actions: ['setError']
+ }
+ }
+ },
+ [LaunchState.SUBMIT_FAILED]: {
+ on: {
+ SUBMIT: LaunchState.SUBMITTING
+ }
+ },
+ [LaunchState.SUBMIT_SUCCEEDED]: {
+ type: 'final'
+ }
+};
+
+export const taskLaunchMachineConfig: MachineConfig<
+ TaskLaunchContext,
+ TaskLaunchSchema,
+ TaskLaunchEvent
+> = {
+ id: 'launchTask',
+ context: { ...defaultBaseContext },
+ initial: LaunchState.LOADING_TASK_VERSIONS,
+ on: {
+ ...defaultHandlers,
+ SELECT_TASK_VERSION: {
+ target: LaunchState.LOADING_INPUTS,
+ actions: ['setTaskVersion']
+ }
+ },
+ states: {
+ ...(baseStateConfig as StatesConfig<
+ TaskLaunchContext,
+ TaskLaunchSchema,
+ TaskLaunchEvent
+ >),
+ [LaunchState.LOADING_TASK_VERSIONS]: {
+ invoke: {
+ src: 'loadTaskVersions',
+ onDone: {
+ target: LaunchState.SELECT_TASK_VERSION,
+ actions: ['setTaskVersionOptions']
+ },
+ onError: {
+ target: LaunchState.FAILED_LOADING_TASK_VERSIONS,
+ actions: ['setError']
+ }
+ }
+ },
+ [LaunchState.FAILED_LOADING_TASK_VERSIONS]: {
+ on: {
+ RETRY: LaunchState.LOADING_TASK_VERSIONS
+ }
+ },
+ [LaunchState.SELECT_TASK_VERSION]: {
+ // events handled at top level
+ }
+ }
+};
+
+export const workflowLaunchMachineConfig: MachineConfig<
+ WorkflowLaunchContext,
+ WorkflowLaunchSchema,
+ WorkflowLaunchEvent
+> = {
+ id: 'launchWorkflow',
+ context: { ...defaultBaseContext },
+ initial: LaunchState.LOADING_WORKFLOW_VERSIONS,
+ on: {
+ ...defaultHandlers,
+ SELECT_WORKFLOW_VERSION: {
+ target: LaunchState.LOADING_LAUNCH_PLANS,
+ actions: ['setWorkflowVersion']
+ },
+ SELECT_LAUNCH_PLAN: {
+ target: LaunchState.LOADING_INPUTS,
+ actions: ['setLaunchPlan']
+ }
+ },
+ states: {
+ ...(baseStateConfig as StatesConfig<
+ WorkflowLaunchContext,
+ WorkflowLaunchSchema,
+ WorkflowLaunchEvent
+ >),
+ [LaunchState.LOADING_WORKFLOW_VERSIONS]: {
+ invoke: {
+ src: 'loadWorkflowVersions',
+ onDone: {
+ target: LaunchState.SELECT_WORKFLOW_VERSION,
+ actions: ['setWorkflowVersionOptions']
+ },
+ onError: {
+ target: LaunchState.FAILED_LOADING_WORKFLOW_VERSIONS,
+ actions: ['setError']
+ }
+ }
+ },
+ [LaunchState.FAILED_LOADING_WORKFLOW_VERSIONS]: {
+ on: {
+ RETRY: LaunchState.LOADING_WORKFLOW_VERSIONS
+ }
+ },
+ [LaunchState.SELECT_WORKFLOW_VERSION]: {
+ // Events handled at top level
+ },
+ [LaunchState.LOADING_LAUNCH_PLANS]: {
+ invoke: {
+ src: 'loadLaunchPlans',
+ onDone: {
+ target: LaunchState.SELECT_LAUNCH_PLAN,
+ actions: ['setLaunchPlanOptions']
+ },
+ onError: {
+ target: LaunchState.FAILED_LOADING_LAUNCH_PLANS,
+ actions: ['setError']
+ }
+ }
+ },
+ [LaunchState.FAILED_LOADING_LAUNCH_PLANS]: {
+ on: {
+ RETRY: LaunchState.LOADING_LAUNCH_PLANS
+ }
+ },
+ [LaunchState.SELECT_LAUNCH_PLAN]: {
+ // events handled at top level
+ }
+ }
+};
+
+type BaseMachineOptions = MachineOptions;
+
+const baseActions: BaseMachineOptions['actions'] = {
+ hideErrors: assign(_ => ({ showErrors: false })),
+ setExecutionId: assign((_, event) => ({
+ resultExecutionId: (event as ExecutionCreatedEvent).data
+ })),
+ setInputs: assign((_, event) => {
+ const {
+ parsedInputs,
+ unsupportedRequiredInputs
+ } = (event as InputsParsedEvent).data;
+ return {
+ parsedInputs,
+ unsupportedRequiredInputs
+ };
+ }),
+ setError: assign((_, event) => ({
+ error: (event as ErrorEvent).data
+ })),
+ showErrors: assign(_ => ({ showErrors: true }))
+};
+
+const baseServices: BaseMachineOptions['services'] = {
+ loadInputs: () =>
+ Promise.reject('No `loadInputs` service has been provided'),
+ submit: () => Promise.reject('No `submit` service has been provided'),
+ validate: () => Promise.reject('No `validate` service has been provided')
+};
+
+export const taskLaunchMachine = Machine(taskLaunchMachineConfig, {
+ actions: {
+ ...baseActions,
+ setTaskVersion: assign((_, event) => ({
+ taskVersion: (event as SelectTaskVersionEvent).taskId
+ })),
+ setTaskVersionOptions: assign((_, event) => ({
+ taskVersionOptions: (event as TaskVersionOptionsLoadedEvent).data
+ }))
+ },
+ services: {
+ ...baseServices,
+ loadTaskVersions: () =>
+ Promise.reject('No `loadTaskVersions` service has been provided')
+ }
+});
+
+/** A full machine for representing the Launch flow, combining the state definitions
+ * with actions/guards/services needed to support them.
+ */
+export const workflowLaunchMachine = Machine(workflowLaunchMachineConfig, {
+ actions: {
+ ...baseActions,
+ setWorkflowVersion: assign((_, event) => ({
+ workflowVersion: (event as SelectWorkflowVersionEvent).workflowId
+ })),
+ setWorkflowVersionOptions: assign((_, event) => ({
+ workflowVersionOptions: (event as DoneInvokeEvent).data
+ })),
+ setLaunchPlanOptions: assign((_, event) => ({
+ launchPlanOptions: (event as LaunchPlanOptionsLoadedEvent).data
+ })),
+ setLaunchPlan: assign((_, event) => ({
+ launchPlan: (event as SelectLaunchPlanEvent).launchPlan
+ }))
+ },
+ services: {
+ ...baseServices,
+ loadWorkflowVersions: () =>
+ Promise.reject(
+ 'No `loadWorkflowVersions` service has been provided'
+ ),
+ loadLaunchPlans: () =>
+ Promise.reject('No `loadLaunchPlans` service has been provided')
+ }
+});
diff --git a/src/components/Launch/LaunchForm/services.ts b/src/components/Launch/LaunchForm/services.ts
new file mode 100644
index 000000000..248c80710
--- /dev/null
+++ b/src/components/Launch/LaunchForm/services.ts
@@ -0,0 +1,18 @@
+import { RefObject } from 'react';
+import { WorkflowLaunchContext } from './launchMachine';
+import { LaunchFormInputsRef } from './types';
+
+export async function validate(
+ formInputsRef: RefObject,
+ {}: WorkflowLaunchContext
+) {
+ if (formInputsRef.current === null) {
+ throw new Error('Unexpected empty form inputs ref');
+ }
+
+ if (!formInputsRef.current.validate()) {
+ throw new Error(
+ 'Some inputs have errors. Please correct them before submitting.'
+ );
+ }
+}
diff --git a/src/components/Launch/LaunchWorkflowForm/styles.ts b/src/components/Launch/LaunchForm/styles.ts
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/styles.ts
rename to src/components/Launch/LaunchForm/styles.ts
diff --git a/src/components/Launch/LaunchForm/test/LaunchTaskForm.test.tsx b/src/components/Launch/LaunchForm/test/LaunchTaskForm.test.tsx
new file mode 100644
index 000000000..f88ad7d25
--- /dev/null
+++ b/src/components/Launch/LaunchForm/test/LaunchTaskForm.test.tsx
@@ -0,0 +1,593 @@
+import { ThemeProvider } from '@material-ui/styles';
+import {
+ act,
+ fireEvent,
+ getAllByRole,
+ getByLabelText,
+ getByRole,
+ queryAllByRole,
+ render,
+ waitFor
+} from '@testing-library/react';
+import { mockAPIContextValue } from 'components/data/__mocks__/apiContext';
+import { APIContext } from 'components/data/apiContext';
+import { muiTheme } from 'components/Theme';
+import { Core } from 'flyteidl';
+import { cloneDeep, get } from 'lodash';
+import {
+ createWorkflowExecution,
+ CreateWorkflowExecutionArguments,
+ getTask,
+ Identifier,
+ listTasks,
+ NamedEntityIdentifier,
+ RequestConfig,
+ Task,
+ Variable
+} from 'models';
+import { createMockTaskClosure } from 'models/__mocks__/taskData';
+import * as React from 'react';
+import { delayedPromise, pendingPromise } from 'test/utils';
+import {
+ createMockInputsInterface,
+ mockSimpleVariables,
+ simpleVariableDefaults
+} from '../__mocks__/mockInputs';
+import {
+ cannotLaunchTaskString,
+ formStrings,
+ requiredInputSuffix
+} from '../constants';
+import { LaunchForm } from '../LaunchForm';
+import { LaunchFormProps, TaskInitialLaunchParameters } from '../types';
+import { createInputCacheKey, getInputDefintionForLiteralType } from '../utils';
+import {
+ binaryInputName,
+ booleanInputName,
+ floatInputName,
+ integerInputName,
+ stringInputName
+} from './constants';
+import { createMockObjects } from './utils';
+
+describe('LaunchForm: Task', () => {
+ let onClose: jest.Mock;
+ let mockTask: Task;
+ let mockTaskVersions: Task[];
+ let taskId: NamedEntityIdentifier;
+ let variables: Record;
+
+ let mockListTasks: jest.Mock>;
+ let mockGetTask: jest.Mock>;
+ let mockCreateWorkflowExecution: jest.Mock>;
+
+ beforeEach(() => {
+ onClose = jest.fn();
+ });
+
+ const createMockTaskWithInputs = (id: Identifier) => {
+ const task: Task = {
+ id,
+ closure: createMockTaskClosure()
+ };
+ task.closure!.compiledTask!.template.interface = createMockInputsInterface(
+ variables
+ );
+ return task;
+ };
+
+ const createMocks = () => {
+ const mockObjects = createMockObjects(variables);
+ mockTask = mockObjects.mockTask;
+
+ mockTaskVersions = mockObjects.mockTaskVersions;
+
+ taskId = mockTask.id;
+ mockCreateWorkflowExecution = jest.fn();
+ // Return our mock inputs for any version requested
+ mockGetTask = jest
+ .fn()
+ .mockImplementation(id =>
+ Promise.resolve(createMockTaskWithInputs(id))
+ );
+
+ // For workflow/task list endpoints: If the scope has a filter, the calling
+ // code is searching for a specific item. So we'll return a single-item
+ // list containing it.
+ mockListTasks = jest
+ .fn()
+ .mockImplementation(
+ (scope: Partial, { filter }: RequestConfig) => {
+ if (filter && filter[0].key === 'version') {
+ const task = { ...mockTaskVersions[0] };
+ task.id = {
+ ...scope,
+ version: filter[0].value
+ } as Identifier;
+ return Promise.resolve({
+ entities: [task]
+ });
+ }
+ return Promise.resolve({ entities: mockTaskVersions });
+ }
+ );
+ };
+
+ const renderForm = (props?: Partial) => {
+ return render(
+
+
+
+
+
+ );
+ };
+
+ const getSubmitButton = (container: HTMLElement) => {
+ const buttons = queryAllByRole(container, 'button').filter(
+ el => el.getAttribute('type') === 'submit'
+ );
+ expect(buttons.length).toBe(1);
+ return buttons[0];
+ };
+
+ const fillInputs = (container: HTMLElement) => {
+ fireEvent.change(
+ getByLabelText(container, stringInputName, {
+ exact: false
+ }),
+ { target: { value: 'abc' } }
+ );
+ fireEvent.change(
+ getByLabelText(container, integerInputName, {
+ exact: false
+ }),
+ { target: { value: '10' } }
+ );
+ fireEvent.change(
+ getByLabelText(container, floatInputName, {
+ exact: false
+ }),
+ { target: { value: '1.5' } }
+ );
+ };
+
+ describe('With Simple Inputs', () => {
+ beforeEach(() => {
+ const {
+ simpleString,
+ simpleInteger,
+ simpleFloat,
+ simpleBoolean
+ } = cloneDeep(mockSimpleVariables);
+ // Only taking supported variable types since they are all required.
+ variables = {
+ simpleString,
+ simpleInteger,
+ simpleFloat,
+ simpleBoolean
+ };
+ createMocks();
+ });
+
+ it('should not show task selector until options have loaded', async () => {
+ mockListTasks.mockReturnValue(pendingPromise());
+ const { getByText, queryByText } = renderForm();
+ await waitFor(() => getByText(formStrings.title));
+ expect(
+ queryByText(formStrings.taskVersion)
+ ).not.toBeInTheDocument();
+ });
+
+ it('should select the most recent task version by default', async () => {
+ const { getByLabelText } = renderForm();
+ const versionEl = await waitFor(() =>
+ getByLabelText(formStrings.taskVersion)
+ );
+ expect(versionEl).toHaveValue(mockTaskVersions[0].id.version);
+ });
+
+ it('should disable submit button until inputs have loaded', async () => {
+ let identifier: Identifier = {} as Identifier;
+ const { promise, resolve } = delayedPromise();
+ mockGetTask.mockImplementation(id => {
+ identifier = id;
+ return promise;
+ });
+ const { container } = renderForm();
+
+ const submitButton = await waitFor(() =>
+ getSubmitButton(container)
+ );
+
+ expect(submitButton).toBeDisabled();
+ resolve(createMockTaskWithInputs(identifier));
+
+ await waitFor(() => expect(submitButton).not.toBeDisabled());
+ });
+
+ it('should not show validation errors until first submit', async () => {
+ const { container, getByLabelText } = renderForm();
+ const integerInput = await waitFor(() =>
+ getByLabelText(integerInputName, {
+ exact: false
+ })
+ );
+ fireEvent.change(integerInput, { target: { value: 'abc' } });
+
+ await waitFor(() => expect(integerInput).not.toBeInvalid());
+
+ fireEvent.click(getSubmitButton(container));
+ await waitFor(() => expect(integerInput).toBeInvalid());
+ });
+
+ it('should update validation errors while typing', async () => {
+ const { container, getByLabelText } = renderForm();
+ await waitFor(() => {});
+
+ const integerInput = await waitFor(() =>
+ getByLabelText(integerInputName, {
+ exact: false
+ })
+ );
+ fireEvent.change(integerInput, { target: { value: 'abc' } });
+ fireEvent.click(getSubmitButton(container));
+ await waitFor(() => expect(integerInput).toBeInvalid());
+
+ fireEvent.change(integerInput, { target: { value: '123' } });
+ await waitFor(() => expect(integerInput).toBeValid());
+ });
+
+ it('should update inputs when selecting a new task version', async () => {
+ const { queryByLabelText, getByTitle } = renderForm();
+ const taskVersionDiv = await waitFor(() =>
+ getByTitle(formStrings.taskVersion)
+ );
+
+ // Delete the string input so that its corresponding input will
+ // disappear after the new launch plan is loaded.
+ delete variables[stringInputName];
+
+ // Click the expander for the task version, select the second item
+ const expander = getByRole(taskVersionDiv, 'button');
+ fireEvent.click(expander);
+ const items = await waitFor(() =>
+ getAllByRole(taskVersionDiv, 'menuitem')
+ );
+ fireEvent.click(items[1]);
+
+ await waitFor(() => getByTitle(formStrings.inputs));
+ expect(
+ queryByLabelText(stringInputName, {
+ // Don't use exact match because the label will be decorated with type info
+ exact: false
+ })
+ ).toBeNull();
+ });
+
+ it('should preserve input values when changing task version', async () => {
+ const { getByLabelText, getByTitle } = renderForm();
+
+ const integerInput = await waitFor(() =>
+ getByLabelText(integerInputName, {
+ exact: false
+ })
+ );
+ fireEvent.change(integerInput, { target: { value: '10' } });
+
+ // Click the expander for the task version, select the second item
+ const taskVersionDiv = getByTitle(formStrings.taskVersion);
+ const expander = getByRole(taskVersionDiv, 'button');
+ fireEvent.click(expander);
+ const items = await waitFor(() =>
+ getAllByRole(taskVersionDiv, 'menuitem')
+ );
+ fireEvent.click(items[1]);
+ await waitFor(() => getByTitle(formStrings.inputs));
+
+ expect(
+ getByLabelText(integerInputName, {
+ exact: false
+ })
+ ).toHaveValue('10');
+ });
+
+ it('should reset form error when inputs change', async () => {
+ const errorString = 'Something went wrong';
+ mockCreateWorkflowExecution.mockRejectedValue(
+ new Error(errorString)
+ );
+
+ const {
+ container,
+ getByText,
+ getByTitle,
+ queryByText
+ } = renderForm();
+ await waitFor(() => getByTitle(formStrings.inputs));
+ fillInputs(container);
+
+ fireEvent.click(getSubmitButton(container));
+ await waitFor(() =>
+ expect(getByText(errorString)).toBeInTheDocument()
+ );
+
+ // Click the expander for the launch plan, select the second item
+ const taskVersionDiv = getByTitle(formStrings.taskVersion);
+ const expander = getByRole(taskVersionDiv, 'button');
+ fireEvent.click(expander);
+ const items = await waitFor(() =>
+ getAllByRole(taskVersionDiv, 'menuitem')
+ );
+ fireEvent.click(items[1]);
+ await waitFor(() =>
+ expect(queryByText(errorString)).not.toBeInTheDocument()
+ );
+ });
+
+ describe('Input Values', () => {
+ it('Should send false for untouched toggles', async () => {
+ let inputs: Core.ILiteralMap = {};
+ mockCreateWorkflowExecution.mockImplementation(
+ ({
+ inputs: passedInputs
+ }: CreateWorkflowExecutionArguments) => {
+ inputs = passedInputs;
+ return pendingPromise();
+ }
+ );
+
+ const { container, getByTitle } = renderForm();
+ await waitFor(() => getByTitle(formStrings.inputs));
+ fillInputs(container);
+
+ fireEvent.click(getSubmitButton(container));
+ await waitFor(() =>
+ expect(mockCreateWorkflowExecution).toHaveBeenCalled()
+ );
+
+ expect(inputs.literals).toBeDefined();
+ const value = get(
+ inputs.literals,
+ `${booleanInputName}.scalar.primitive.boolean`
+ );
+ expect(value).toBe(false);
+ });
+
+ it('should decorate all inputs with required labels', async () => {
+ const { getByTitle, queryAllByText } = renderForm();
+ await waitFor(() => getByTitle(formStrings.inputs));
+ Object.keys(variables).forEach(name => {
+ const elements = queryAllByText(name, {
+ exact: false
+ });
+ expect(elements.length).toBeGreaterThan(0);
+ expect(elements[0].textContent).toContain('*');
+ });
+ });
+ });
+
+ describe('When using initial parameters', () => {
+ it('should prefer the provided task version', async () => {
+ const initialParameters: TaskInitialLaunchParameters = {
+ taskId: mockTaskVersions[2].id
+ };
+ const { getByLabelText } = renderForm({ initialParameters });
+ await waitFor(() =>
+ expect(getByLabelText(formStrings.taskVersion)).toHaveValue(
+ mockTaskVersions[2].id.version
+ )
+ );
+ });
+
+ it('should only include one instance of the preferred version in the selector', async () => {
+ const initialParameters: TaskInitialLaunchParameters = {
+ taskId: mockTaskVersions[2].id
+ };
+ const { getByTitle } = renderForm({ initialParameters });
+
+ // Click the expander for the workflow, select the second item
+ const versionDiv = await waitFor(() =>
+ getByTitle(formStrings.taskVersion)
+ );
+ const expander = getByRole(versionDiv, 'button');
+ fireEvent.click(expander);
+ const items = await waitFor(() =>
+ getAllByRole(versionDiv, 'menuitem')
+ );
+
+ const expectedVersion = mockTaskVersions[2].id.version;
+ expect(
+ items.filter(
+ item =>
+ item.textContent &&
+ item.textContent.includes(expectedVersion)
+ )
+ ).toHaveLength(1);
+ });
+
+ it('should fall back to the first item in the list if preferred version is not found', async () => {
+ mockListTasks.mockImplementation(
+ (scope: Partial) => {
+ // If we get a request for a specific item,
+ // simulate not found
+ if (scope.version) {
+ return Promise.resolve({ entities: [] });
+ }
+ return Promise.resolve({
+ entities: mockTaskVersions
+ });
+ }
+ );
+ const baseId = mockTaskVersions[2].id;
+ const initialParameters: TaskInitialLaunchParameters = {
+ taskId: { ...baseId, version: 'nonexistentValue' }
+ };
+ const { getByLabelText } = renderForm({ initialParameters });
+ await waitFor(() =>
+ expect(getByLabelText(formStrings.taskVersion)).toHaveValue(
+ mockTaskVersions[0].id.version
+ )
+ );
+ });
+
+ it('should prepopulate inputs with provided initial values', async () => {
+ const stringValue = 'initialStringValue';
+ const initialStringValue: Core.ILiteral = {
+ scalar: { primitive: { stringValue } }
+ };
+ const values = new Map();
+ const stringCacheKey = createInputCacheKey(
+ stringInputName,
+ getInputDefintionForLiteralType(
+ variables[stringInputName].type
+ )
+ );
+ values.set(stringCacheKey, initialStringValue);
+ const { getByLabelText } = renderForm({
+ initialParameters: { values }
+ });
+ await waitFor(() =>
+ expect(
+ getByLabelText(stringInputName, { exact: false })
+ ).toHaveValue(stringValue)
+ );
+ });
+
+ it('loads preferred task version when it does not exist in the list of suggestions', async () => {
+ const missingTask = mockTaskVersions[0];
+ missingTask.id.version = 'missingVersionString';
+ const initialParameters: TaskInitialLaunchParameters = {
+ taskId: missingTask.id
+ };
+ const { getByLabelText } = renderForm({ initialParameters });
+ await waitFor(() =>
+ expect(getByLabelText(formStrings.taskVersion)).toHaveValue(
+ missingTask.id.version
+ )
+ );
+ });
+
+ it('should select contents of task version input on focus', async () => {
+ const { getByLabelText } = renderForm();
+
+ // Focus the workflow version input
+ const workflowInput = await waitFor(() =>
+ getByLabelText(formStrings.taskVersion)
+ );
+ fireEvent.focus(workflowInput);
+
+ const expectedValue = mockTaskVersions[0].id.version;
+
+ // The value should remain, but selection should be the entire string
+ await waitFor(() =>
+ expect(workflowInput).toHaveValue(expectedValue)
+ );
+ expect((workflowInput as HTMLInputElement).selectionEnd).toBe(
+ expectedValue.length
+ );
+ });
+
+ it('should correctly render task version search results', async () => {
+ const initialParameters: TaskInitialLaunchParameters = {
+ taskId: mockTaskVersions[2].id
+ };
+ const inputString = mockTaskVersions[1].id.version.substring(
+ 0,
+ 4
+ );
+ const { getByLabelText } = renderForm({ initialParameters });
+
+ const versionInput = await waitFor(() =>
+ getByLabelText(formStrings.taskVersion)
+ );
+ mockListTasks.mockClear();
+
+ fireEvent.change(versionInput, {
+ target: { value: inputString }
+ });
+
+ const { project, domain, name } = mockTaskVersions[2].id;
+ await waitFor(() =>
+ expect(mockListTasks).toHaveBeenCalledWith(
+ { project, domain, name },
+ expect.anything()
+ )
+ );
+ });
+ });
+
+ describe('With Unsupported Required Inputs', () => {
+ beforeEach(() => {
+ // Binary is currently unsupported, and all values are required.
+ // So adding a binary variable will generate our test case.
+ variables[binaryInputName] = cloneDeep(
+ mockSimpleVariables[binaryInputName]
+ );
+ });
+
+ it('should render error message', async () => {
+ const { getByText } = renderForm();
+ const errorElement = await waitFor(() =>
+ getByText(cannotLaunchTaskString)
+ );
+ expect(errorElement).toBeInTheDocument();
+ });
+
+ it('should show unsupported inputs', async () => {
+ const { getByText } = renderForm();
+ const inputElement = await waitFor(() =>
+ getByText(binaryInputName, { exact: false })
+ );
+ expect(inputElement).toBeInTheDocument();
+ });
+
+ it('should print input labels without decoration', async () => {
+ const { getByText } = renderForm();
+ const inputElement = await waitFor(() =>
+ getByText(binaryInputName, { exact: false })
+ );
+ expect(inputElement.textContent).not.toContain(
+ requiredInputSuffix
+ );
+ });
+
+ it('should disable submission', async () => {
+ const { getByRole } = renderForm();
+
+ const submitButton = await waitFor(() =>
+ getByRole('button', { name: formStrings.submit })
+ );
+
+ expect(submitButton).toBeDisabled();
+ });
+
+ it('should not show error if initial value is provided', async () => {
+ const values = new Map();
+ const cacheKey = createInputCacheKey(
+ binaryInputName,
+ getInputDefintionForLiteralType(
+ variables[binaryInputName].type
+ )
+ );
+ values.set(cacheKey, simpleVariableDefaults.simpleBinary);
+ const { getByLabelText, queryByText } = renderForm({
+ initialParameters: { values }
+ });
+
+ await waitFor(() =>
+ getByLabelText(binaryInputName, { exact: false })
+ );
+ expect(queryByText(cannotLaunchTaskString)).toBeNull();
+ });
+ });
+ });
+});
diff --git a/src/components/Launch/LaunchWorkflowForm/test/LaunchWorkflowForm.test.tsx b/src/components/Launch/LaunchForm/test/LaunchWorkflowForm.test.tsx
similarity index 94%
rename from src/components/Launch/LaunchWorkflowForm/test/LaunchWorkflowForm.test.tsx
rename to src/components/Launch/LaunchForm/test/LaunchWorkflowForm.test.tsx
index 9ed331d9d..6ba6e2a06 100644
--- a/src/components/Launch/LaunchWorkflowForm/test/LaunchWorkflowForm.test.tsx
+++ b/src/components/Launch/LaunchForm/test/LaunchWorkflowForm.test.tsx
@@ -32,7 +32,7 @@ import { createMockWorkflowClosure } from 'models/__mocks__/workflowData';
import * as React from 'react';
import { delayedPromise, pendingPromise } from 'test/utils';
import {
- createMockWorkflowInputsInterface,
+ createMockInputsInterface,
mockSimpleVariables,
simpleVariableDefaults
} from '../__mocks__/mockInputs';
@@ -41,8 +41,8 @@ import {
formStrings,
requiredInputSuffix
} from '../constants';
-import { LaunchWorkflowForm } from '../LaunchWorkflowForm';
-import { InitialLaunchParameters, LaunchWorkflowFormProps } from '../types';
+import { LaunchForm } from '../LaunchForm';
+import { LaunchFormProps, WorkflowInitialLaunchParameters } from '../types';
import { createInputCacheKey, getInputDefintionForLiteralType } from '../utils';
import {
binaryInputName,
@@ -53,7 +53,7 @@ import {
} from './constants';
import { createMockObjects } from './utils';
-describe('LaunchWorkflowForm', () => {
+describe('LaunchForm: Workflow', () => {
let onClose: jest.Mock;
let mockLaunchPlans: LaunchPlan[];
let mockSingleLaunchPlan: LaunchPlan;
@@ -84,7 +84,7 @@ describe('LaunchWorkflowForm', () => {
id
};
workflow.closure = createMockWorkflowClosure();
- workflow.closure!.compiledWorkflow!.primary.template.interface = createMockWorkflowInputsInterface(
+ workflow.closure!.compiledWorkflow!.primary.template.interface = createMockInputsInterface(
variables
);
return workflow;
@@ -132,13 +132,14 @@ describe('LaunchWorkflowForm', () => {
return Promise.resolve({ entities: mockLaunchPlans });
}
);
+
+ // For workflow/task list endpoints: If the scope has a filter, the calling
+ // code is searching for a specific item. So we'll return a single-item
+ // list containing it.
mockListWorkflows = jest
.fn()
.mockImplementation(
(scope: Partial, { filter }: RequestConfig) => {
- // If the scope has a filter, the calling
- // code is searching for a specific item. So we'll
- // return a single-item list containing it.
if (filter && filter[0].key === 'version') {
const workflow = { ...mockWorkflowVersions[0] };
workflow.id = {
@@ -154,7 +155,7 @@ describe('LaunchWorkflowForm', () => {
);
};
- const renderForm = (props?: Partial) => {
+ const renderForm = (props?: Partial) => {
return render(
{
listWorkflows: mockListWorkflows
})}
>
- {
it('should select the launch plan matching the workflow name by default', async () => {
const { getByLabelText } = renderForm();
- await waitFor(() => {});
- expect(getByLabelText(formStrings.launchPlan)).toHaveValue(
- mockWorkflow.id.name
+ const launchPlanEl = await waitFor(() =>
+ getByLabelText(formStrings.launchPlan)
);
+ expect(launchPlanEl).toHaveValue(mockWorkflow.id.name);
});
it('should not render inputs if no launch plan is selected', async () => {
@@ -303,7 +304,7 @@ describe('LaunchWorkflowForm', () => {
it('should update launch plan when selecting a new workflow version', async () => {
const { getByTitle } = renderForm();
- await waitFor(() => {});
+ await waitFor(() => getByTitle(formStrings.launchPlan));
mockListLaunchPlans.mockClear();
@@ -316,7 +317,7 @@ describe('LaunchWorkflowForm', () => {
);
fireEvent.click(items[1]);
- await waitFor(() => {});
+ await waitFor(() => getByTitle(formStrings.launchPlan));
expect(mockListLaunchPlans).toHaveBeenCalled();
});
@@ -344,7 +345,9 @@ describe('LaunchWorkflowForm', () => {
it('should update inputs when selecting a new launch plan', async () => {
const { queryByLabelText, getByTitle } = renderForm();
- await waitFor(() => {});
+ const launchPlanDiv = await waitFor(() =>
+ getByTitle(formStrings.launchPlan)
+ );
// Delete the string input so that its corresponding input will
// disappear after the new launch plan is loaded.
@@ -353,7 +356,6 @@ describe('LaunchWorkflowForm', () => {
];
// Click the expander for the launch plan, select the second item
- const launchPlanDiv = getByTitle(formStrings.launchPlan);
const expander = getByRole(launchPlanDiv, 'button');
fireEvent.click(expander);
const items = await waitFor(() =>
@@ -361,7 +363,7 @@ describe('LaunchWorkflowForm', () => {
);
fireEvent.click(items[1]);
- await waitFor(() => {});
+ await waitFor(() => getByTitle(formStrings.inputs));
expect(
queryByLabelText(stringInputName, {
// Don't use exact match because the label will be decorated with type info
@@ -499,8 +501,8 @@ describe('LaunchWorkflowForm', () => {
describe('When using initial parameters', () => {
it('should prefer the provided workflow version', async () => {
- const initialParameters: InitialLaunchParameters = {
- workflow: mockWorkflowVersions[2].id
+ const initialParameters: WorkflowInitialLaunchParameters = {
+ workflowId: mockWorkflowVersions[2].id
};
const { getByLabelText } = renderForm({ initialParameters });
await waitFor(() => {});
@@ -510,8 +512,8 @@ describe('LaunchWorkflowForm', () => {
});
it('should only include one instance of the preferred version in the selector', async () => {
- const initialParameters: InitialLaunchParameters = {
- workflow: mockWorkflowVersions[2].id
+ const initialParameters: WorkflowInitialLaunchParameters = {
+ workflowId: mockWorkflowVersions[2].id
};
const { getByTitle } = renderForm({ initialParameters });
await waitFor(() => {});
@@ -547,8 +549,8 @@ describe('LaunchWorkflowForm', () => {
}
);
const baseId = mockWorkflowVersions[2].id;
- const initialParameters: InitialLaunchParameters = {
- workflow: { ...baseId, version: 'nonexistentValue' }
+ const initialParameters: WorkflowInitialLaunchParameters = {
+ workflowId: { ...baseId, version: 'nonexistentValue' }
};
const { getByLabelText } = renderForm({ initialParameters });
await waitFor(() => {});
@@ -558,7 +560,7 @@ describe('LaunchWorkflowForm', () => {
});
it('should prefer the provided launch plan', async () => {
- const initialParameters: InitialLaunchParameters = {
+ const initialParameters: WorkflowInitialLaunchParameters = {
launchPlan: mockLaunchPlans[1].id
};
const { getByLabelText } = renderForm({ initialParameters });
@@ -569,7 +571,7 @@ describe('LaunchWorkflowForm', () => {
});
it('should only include one instance of the preferred launch plan in the selector', async () => {
- const initialParameters: InitialLaunchParameters = {
+ const initialParameters: WorkflowInitialLaunchParameters = {
launchPlan: mockLaunchPlans[1].id
};
const { getByTitle } = renderForm({ initialParameters });
@@ -605,7 +607,7 @@ describe('LaunchWorkflowForm', () => {
);
const launchPlanId = { ...mockLaunchPlans[1].id };
launchPlanId.name = 'InvalidLauchPlan';
- const initialParameters: InitialLaunchParameters = {
+ const initialParameters: WorkflowInitialLaunchParameters = {
launchPlan: launchPlanId
};
const { getByLabelText } = renderForm({ initialParameters });
@@ -672,8 +674,8 @@ describe('LaunchWorkflowForm', () => {
it('loads preferred workflow version when it does not exist in the list of suggestions', async () => {
const missingWorkflow = mockWorkflowVersions[0];
missingWorkflow.id.version = 'missingVersionString';
- const initialParameters: InitialLaunchParameters = {
- workflow: missingWorkflow.id
+ const initialParameters: WorkflowInitialLaunchParameters = {
+ workflowId: missingWorkflow.id
};
const { getByLabelText } = renderForm({ initialParameters });
await waitFor(() => {});
@@ -685,7 +687,7 @@ describe('LaunchWorkflowForm', () => {
it('loads the preferred launch plan when it does not exist in the list of suggestions', async () => {
const missingLaunchPlan = mockLaunchPlans[0];
missingLaunchPlan.id.name = 'missingLaunchPlanName';
- const initialParameters: InitialLaunchParameters = {
+ const initialParameters: WorkflowInitialLaunchParameters = {
launchPlan: missingLaunchPlan.id
};
const { getByLabelText } = renderForm({ initialParameters });
@@ -719,8 +721,8 @@ describe('LaunchWorkflowForm', () => {
});
it('should correctly render workflow version search results', async () => {
- const initialParameters: InitialLaunchParameters = {
- workflow: mockWorkflowVersions[2].id
+ const initialParameters: WorkflowInitialLaunchParameters = {
+ workflowId: mockWorkflowVersions[2].id
};
const inputString = mockWorkflowVersions[1].id.version.substring(
0,
@@ -752,8 +754,6 @@ describe('LaunchWorkflowForm', () => {
describe('With Unsupported Required Inputs', () => {
beforeEach(() => {
- // variables = mockSimpleVariables;
- // createMocks();
// Binary is currently unsupported, setting the binary input to
// required and removing the default value will trigger our use case
const parameters = mockLaunchPlans[0].closure!.expectedInputs
diff --git a/src/components/Launch/LaunchWorkflowForm/test/constants.ts b/src/components/Launch/LaunchForm/test/constants.ts
similarity index 66%
rename from src/components/Launch/LaunchWorkflowForm/test/constants.ts
rename to src/components/Launch/LaunchForm/test/constants.ts
index 1c7df2799..a4f8ab0ae 100644
--- a/src/components/Launch/LaunchWorkflowForm/test/constants.ts
+++ b/src/components/Launch/LaunchForm/test/constants.ts
@@ -1,6 +1,9 @@
export const booleanInputName = 'simpleBoolean';
export const stringInputName = 'simpleString';
export const stringNoLabelName = 'stringNoLabel';
+export const floatInputName = 'simpleFloat';
+export const durationInputName = 'simpleDuration';
+export const datetimeInputName = 'simpleDatetime';
export const integerInputName = 'simpleInteger';
export const binaryInputName = 'simpleBinary';
export const errorInputName = 'simpleError';
diff --git a/src/components/Launch/LaunchWorkflowForm/test/getInputs.test.ts b/src/components/Launch/LaunchForm/test/getInputs.test.ts
similarity index 71%
rename from src/components/Launch/LaunchWorkflowForm/test/getInputs.test.ts
rename to src/components/Launch/LaunchForm/test/getInputs.test.ts
index e9b4fb896..231ff55b4 100644
--- a/src/components/Launch/LaunchWorkflowForm/test/getInputs.test.ts
+++ b/src/components/Launch/LaunchForm/test/getInputs.test.ts
@@ -1,5 +1,5 @@
import { mockSimpleVariables } from '../__mocks__/mockInputs';
-import { getInputs } from '../getInputs';
+import { getInputsForWorkflow } from '../getInputs';
import { stringInputName } from './constants';
import { createMockObjects } from './utils';
@@ -15,9 +15,13 @@ describe('getInputs', () => {
const parameters = launchPlan.closure!.expectedInputs.parameters;
parameters[stringInputName].default = null;
- expect(() => getInputs(mockWorkflow, launchPlan)).not.toThrowError();
+ expect(() =>
+ getInputsForWorkflow(mockWorkflow, launchPlan)
+ ).not.toThrowError();
delete parameters[stringInputName].default;
- expect(() => getInputs(mockWorkflow, launchPlan)).not.toThrowError();
+ expect(() =>
+ getInputsForWorkflow(mockWorkflow, launchPlan)
+ ).not.toThrowError();
});
});
diff --git a/src/components/Launch/LaunchWorkflowForm/test/utils.ts b/src/components/Launch/LaunchForm/test/utils.ts
similarity index 72%
rename from src/components/Launch/LaunchWorkflowForm/test/utils.ts
rename to src/components/Launch/LaunchForm/test/utils.ts
index e641c417f..4ba1353a7 100644
--- a/src/components/Launch/LaunchWorkflowForm/test/utils.ts
+++ b/src/components/Launch/LaunchForm/test/utils.ts
@@ -1,6 +1,10 @@
import { mapValues } from 'lodash';
import { Variable } from 'models';
import { createMockLaunchPlan } from 'models/__mocks__/launchPlanData';
+import {
+ createMockTask,
+ createMockTaskVersions
+} from 'models/__mocks__/taskData';
import {
createMockWorkflow,
createMockWorkflowVersions
@@ -8,12 +12,15 @@ import {
export function createMockObjects(variables: Record) {
const mockWorkflow = createMockWorkflow('MyWorkflow');
+ const mockTask = createMockTask('MyTask');
const mockWorkflowVersions = createMockWorkflowVersions(
mockWorkflow.id.name,
10
);
+ const mockTaskVersions = createMockTaskVersions(mockTask.id.name, 10);
+
const mockLaunchPlans = [mockWorkflow.id.name, 'OtherLaunchPlan'].map(
name => {
const parameterMap = {
@@ -27,5 +34,11 @@ export function createMockObjects(variables: Record) {
return launchPlan;
}
);
- return { mockWorkflow, mockLaunchPlans, mockWorkflowVersions };
+ return {
+ mockWorkflow,
+ mockLaunchPlans,
+ mockTask,
+ mockTaskVersions,
+ mockWorkflowVersions
+ };
}
diff --git a/src/components/Launch/LaunchForm/types.ts b/src/components/Launch/LaunchForm/types.ts
new file mode 100644
index 000000000..eb3c9f679
--- /dev/null
+++ b/src/components/Launch/LaunchForm/types.ts
@@ -0,0 +1,192 @@
+import { Core } from 'flyteidl';
+import {
+ BlobDimensionality,
+ Identifier,
+ LaunchPlan,
+ NamedEntityIdentifier,
+ Task,
+ Workflow,
+ WorkflowExecutionIdentifier,
+ WorkflowId
+} from 'models';
+import { Interpreter, State } from 'xstate';
+import {
+ BaseLaunchContext,
+ BaseLaunchEvent,
+ BaseLaunchTypestate,
+ TaskLaunchContext,
+ TaskLaunchEvent,
+ TaskLaunchTypestate,
+ WorkflowLaunchContext,
+ WorkflowLaunchEvent,
+ WorkflowLaunchTypestate
+} from './launchMachine';
+import { SearchableSelectorOption } from './SearchableSelector';
+
+export type InputValueMap = Map;
+export type LiteralValueMap = Map;
+export type SearchableVersion = Workflow | Task;
+
+export type BaseInterpretedLaunchState = State<
+ BaseLaunchContext,
+ BaseLaunchEvent,
+ any,
+ BaseLaunchTypestate
+>;
+
+export type BaseLaunchService = Interpreter<
+ BaseLaunchContext,
+ any,
+ BaseLaunchEvent,
+ BaseLaunchTypestate
+>;
+
+export interface BaseLaunchFormProps {
+ onClose(): void;
+ referenceExecutionId?: WorkflowExecutionIdentifier;
+}
+
+export interface BaseInitialLaunchParameters {
+ values?: LiteralValueMap;
+}
+
+export interface WorkflowInitialLaunchParameters
+ extends BaseInitialLaunchParameters {
+ launchPlan?: Identifier;
+ workflowId?: WorkflowId;
+}
+export interface LaunchWorkflowFormProps extends BaseLaunchFormProps {
+ workflowId: NamedEntityIdentifier;
+ initialParameters?: WorkflowInitialLaunchParameters;
+}
+
+export interface TaskInitialLaunchParameters
+ extends BaseInitialLaunchParameters {
+ taskId?: Identifier;
+}
+export interface LaunchTaskFormProps extends BaseLaunchFormProps {
+ taskId: NamedEntityIdentifier;
+ initialParameters?: TaskInitialLaunchParameters;
+}
+
+export type LaunchFormProps = LaunchWorkflowFormProps | LaunchTaskFormProps;
+
+export interface LaunchWorkflowFormProps {
+ workflowId: NamedEntityIdentifier;
+ initialParameters?: WorkflowInitialLaunchParameters;
+}
+
+export interface LaunchFormInputsRef {
+ getValues(): Record;
+ validate(): boolean;
+}
+
+export interface WorkflowSourceSelectorState {
+ launchPlanSelectorOptions: SearchableSelectorOption[];
+ selectedWorkflow?: SearchableSelectorOption;
+ selectedLaunchPlan?: SearchableSelectorOption;
+ workflowSelectorOptions: SearchableSelectorOption[];
+ fetchSearchResults(
+ query: string
+ ): Promise[]>;
+ onSelectWorkflowVersion(
+ selected: SearchableSelectorOption
+ ): void;
+ onSelectLaunchPlan(selected: SearchableSelectorOption): void;
+}
+
+export interface TaskSourceSelectorState {
+ selectedTask?: SearchableSelectorOption;
+ taskSelectorOptions: SearchableSelectorOption[];
+ fetchSearchResults(
+ query: string
+ ): Promise[]>;
+ onSelectTaskVersion(selected: SearchableSelectorOption): void;
+}
+
+export interface LaunchWorkflowFormState {
+ formInputsRef: React.RefObject;
+ state: State<
+ WorkflowLaunchContext,
+ WorkflowLaunchEvent,
+ any,
+ WorkflowLaunchTypestate
+ >;
+ service: Interpreter<
+ WorkflowLaunchContext,
+ any,
+ WorkflowLaunchEvent,
+ WorkflowLaunchTypestate
+ >;
+ workflowSourceSelectorState: WorkflowSourceSelectorState;
+}
+
+export interface LaunchTaskFormState {
+ formInputsRef: React.RefObject;
+ state: State;
+ service: Interpreter<
+ TaskLaunchContext,
+ any,
+ TaskLaunchEvent,
+ TaskLaunchTypestate
+ >;
+ taskSourceSelectorState: TaskSourceSelectorState;
+}
+
+export enum InputType {
+ Binary = 'BINARY',
+ Blob = 'BLOB',
+ Boolean = 'BOOLEAN',
+ Collection = 'COLLECTION',
+ Datetime = 'DATETIME',
+ Duration = 'DURATION',
+ Error = 'ERROR',
+ Float = 'FLOAT',
+ Integer = 'INTEGER',
+ Map = 'MAP',
+ None = 'NONE',
+ Schema = 'SCHEMA',
+ String = 'STRING',
+ Struct = 'STRUCT',
+ Unknown = 'UNKNOWN'
+}
+
+export interface InputTypeDefinition {
+ type: InputType;
+ subtype?: InputTypeDefinition;
+}
+
+export interface ObjectValue {
+ type: InputType;
+}
+
+export interface BlobValue {
+ dimensionality: BlobDimensionality | string;
+ format?: string;
+ uri: string;
+}
+
+export type InputValue = string | number | boolean | Date | BlobValue;
+export type InputChangeHandler = (newValue: InputValue) => void;
+
+export interface InputProps {
+ description: string;
+ error?: string;
+ helperText?: string;
+ initialValue?: Core.ILiteral;
+ name: string;
+ label: string;
+ required: boolean;
+ typeDefinition: InputTypeDefinition;
+ value?: InputValue;
+ onChange: InputChangeHandler;
+}
+
+export interface ParsedInput
+ extends Pick<
+ InputProps,
+ 'description' | 'label' | 'name' | 'required' | 'typeDefinition'
+ > {
+ /** Provides an initial value for the input, which can be changed by the user. */
+ initialValue?: Core.ILiteral;
+}
diff --git a/src/components/Launch/LaunchWorkflowForm/useFormInputsState.ts b/src/components/Launch/LaunchForm/useFormInputsState.ts
similarity index 100%
rename from src/components/Launch/LaunchWorkflowForm/useFormInputsState.ts
rename to src/components/Launch/LaunchForm/useFormInputsState.ts
diff --git a/src/components/Launch/LaunchForm/useLaunchTaskFormState.ts b/src/components/Launch/LaunchForm/useLaunchTaskFormState.ts
new file mode 100644
index 000000000..2338dd6b6
--- /dev/null
+++ b/src/components/Launch/LaunchForm/useLaunchTaskFormState.ts
@@ -0,0 +1,229 @@
+import { useMachine } from '@xstate/react';
+import { defaultStateMachineConfig } from 'components/common/constants';
+import { APIContextValue, useAPIContext } from 'components/data/apiContext';
+import { isEqual, partial, uniqBy } from 'lodash';
+import {
+ FilterOperationName,
+ Identifier,
+ SortDirection,
+ Task,
+ taskSortFields,
+ WorkflowExecutionIdentifier
+} from 'models';
+import { RefObject, useEffect, useMemo, useRef } from 'react';
+import { getInputsForTask } from './getInputs';
+import {
+ LaunchState,
+ TaskLaunchContext,
+ TaskLaunchEvent,
+ taskLaunchMachine,
+ TaskLaunchTypestate
+} from './launchMachine';
+import { validate } from './services';
+import {
+ LaunchFormInputsRef,
+ LaunchTaskFormProps,
+ LaunchTaskFormState,
+ ParsedInput
+} from './types';
+import { useTaskSourceSelectorState } from './useTaskSourceSelectorState';
+import { getUnsupportedRequiredInputs } from './utils';
+
+async function loadTaskVersions(
+ { listTasks }: APIContextValue,
+ { preferredTaskId, sourceId }: TaskLaunchContext
+) {
+ if (!sourceId) {
+ throw new Error('Cannot load tasks, missing sourceId');
+ }
+ const { project, domain, name } = sourceId;
+ const tasksPromise = listTasks(
+ { project, domain, name },
+ {
+ limit: 10,
+ sort: {
+ key: taskSortFields.createdAt,
+ direction: SortDirection.DESCENDING
+ }
+ }
+ );
+
+ let preferredTaskPromise = Promise.resolve({
+ entities: [] as Task[]
+ });
+ if (preferredTaskId) {
+ const { version, ...scope } = preferredTaskId;
+ preferredTaskPromise = listTasks(scope, {
+ limit: 1,
+ filter: [
+ {
+ key: 'version',
+ operation: FilterOperationName.EQ,
+ value: version
+ }
+ ]
+ });
+ }
+
+ const [tasksResult, preferredTaskResult] = await Promise.all([
+ tasksPromise,
+ preferredTaskPromise
+ ]);
+ const merged = [...tasksResult.entities, ...preferredTaskResult.entities];
+ return uniqBy(merged, ({ id: { version } }) => version);
+}
+
+async function loadInputs(
+ { getTask }: APIContextValue,
+ { defaultInputValues, taskVersion }: TaskLaunchContext
+) {
+ if (!taskVersion) {
+ throw new Error('Failed to load inputs: missing taskVersion');
+ }
+
+ const task = await getTask(taskVersion);
+ const parsedInputs: ParsedInput[] = getInputsForTask(
+ task,
+ defaultInputValues
+ );
+
+ return {
+ parsedInputs,
+ unsupportedRequiredInputs: getUnsupportedRequiredInputs(parsedInputs)
+ };
+}
+
+async function submit(
+ { createWorkflowExecution }: APIContextValue,
+ formInputsRef: RefObject,
+ { referenceExecutionId, taskVersion }: TaskLaunchContext
+) {
+ if (!taskVersion) {
+ throw new Error('Attempting to launch with no Task version');
+ }
+ if (formInputsRef.current === null) {
+ throw new Error('Unexpected empty form inputs ref');
+ }
+ const literals = formInputsRef.current.getValues();
+ const launchPlanId = taskVersion;
+ const { domain, project } = taskVersion;
+
+ const response = await createWorkflowExecution({
+ domain,
+ launchPlanId,
+ project,
+ referenceExecutionId,
+ inputs: { literals }
+ });
+ const newExecutionId = response.id as WorkflowExecutionIdentifier;
+ if (!newExecutionId) {
+ throw new Error('API Response did not include new execution id');
+ }
+
+ return newExecutionId;
+}
+
+function getServices(
+ apiContext: APIContextValue,
+ formInputsRef: RefObject
+) {
+ return {
+ loadTaskVersions: partial(loadTaskVersions, apiContext),
+ loadInputs: partial(loadInputs, apiContext),
+ submit: partial(submit, apiContext, formInputsRef),
+ validate: partial(validate, formInputsRef)
+ };
+}
+
+/** Contains all of the form state for a LaunchTaskForm, including input
+ * definitions, current input values, and errors.
+ */
+export function useLaunchTaskFormState({
+ initialParameters = {},
+ taskId: sourceId,
+ referenceExecutionId
+}: LaunchTaskFormProps): LaunchTaskFormState {
+ // These values will be used to auto-select items from the task
+ // version/launch plan drop downs.
+ const {
+ taskId: preferredTaskId,
+ values: defaultInputValues
+ } = initialParameters;
+
+ const apiContext = useAPIContext();
+ const formInputsRef = useRef(null);
+
+ const services = useMemo(() => getServices(apiContext, formInputsRef), [
+ apiContext,
+ formInputsRef
+ ]);
+
+ const [state, sendEvent, service] = useMachine<
+ TaskLaunchContext,
+ TaskLaunchEvent,
+ TaskLaunchTypestate
+ >(taskLaunchMachine, {
+ ...defaultStateMachineConfig,
+ services,
+ context: {
+ defaultInputValues,
+ preferredTaskId,
+ referenceExecutionId,
+ sourceId
+ }
+ });
+
+ const { taskVersionOptions = [], taskVersion } = state.context;
+
+ const selectTaskVersion = (newTask: Identifier) => {
+ if (newTask === taskVersion) {
+ return;
+ }
+ sendEvent({
+ type: 'SELECT_TASK_VERSION',
+ taskId: newTask
+ });
+ };
+
+ const taskSourceSelectorState = useTaskSourceSelectorState({
+ sourceId,
+ selectTaskVersion,
+ taskVersion,
+ taskVersionOptions
+ });
+
+ useEffect(() => {
+ const subscription = service.subscribe(newState => {
+ if (newState.matches(LaunchState.SELECT_TASK_VERSION)) {
+ const {
+ taskVersionOptions,
+ preferredTaskId
+ } = newState.context;
+ if (taskVersionOptions.length > 0) {
+ let taskToSelect = taskVersionOptions[0];
+ if (preferredTaskId) {
+ const preferred = taskVersionOptions.find(({ id }) =>
+ isEqual(id, preferredTaskId)
+ );
+ if (preferred) {
+ taskToSelect = preferred;
+ }
+ }
+ sendEvent({
+ type: 'SELECT_TASK_VERSION',
+ taskId: taskToSelect.id
+ });
+ }
+ }
+ });
+
+ return subscription.unsubscribe;
+ }, [service, sendEvent]);
+
+ return {
+ formInputsRef,
+ state,
+ service,
+ taskSourceSelectorState
+ };
+}
diff --git a/src/components/Launch/LaunchForm/useLaunchWorkflowFormState.ts b/src/components/Launch/LaunchForm/useLaunchWorkflowFormState.ts
new file mode 100644
index 000000000..4c58246f7
--- /dev/null
+++ b/src/components/Launch/LaunchForm/useLaunchWorkflowFormState.ts
@@ -0,0 +1,363 @@
+import { useMachine } from '@xstate/react';
+import { defaultStateMachineConfig } from 'components/common/constants';
+import { APIContextValue, useAPIContext } from 'components/data/apiContext';
+import { isEqual, partial, uniqBy } from 'lodash';
+import {
+ FilterOperationName,
+ LaunchPlan,
+ SortDirection,
+ Workflow,
+ WorkflowExecutionIdentifier,
+ WorkflowId,
+ workflowSortFields
+} from 'models';
+import { RefObject, useEffect, useMemo, useRef } from 'react';
+import { getInputsForWorkflow } from './getInputs';
+import {
+ LaunchState,
+ WorkflowLaunchContext,
+ WorkflowLaunchEvent,
+ workflowLaunchMachine,
+ WorkflowLaunchTypestate
+} from './launchMachine';
+import { validate } from './services';
+import {
+ LaunchFormInputsRef,
+ LaunchWorkflowFormProps,
+ LaunchWorkflowFormState,
+ ParsedInput
+} from './types';
+import { useWorkflowSourceSelectorState } from './useWorkflowSourceSelectorState';
+import { getUnsupportedRequiredInputs } from './utils';
+
+async function loadLaunchPlans(
+ { listLaunchPlans }: APIContextValue,
+ { preferredLaunchPlanId, workflowVersion }: WorkflowLaunchContext
+) {
+ if (workflowVersion == null) {
+ return Promise.reject('No workflowVersion specified');
+ }
+
+ let preferredLaunchPlanPromise = Promise.resolve({
+ entities: [] as LaunchPlan[]
+ });
+ if (preferredLaunchPlanId) {
+ const { version, ...scope } = preferredLaunchPlanId;
+ preferredLaunchPlanPromise = listLaunchPlans(scope, {
+ limit: 1,
+ filter: [
+ {
+ key: 'version',
+ operation: FilterOperationName.EQ,
+ value: version
+ }
+ ]
+ });
+ }
+
+ const { project, domain, name, version } = workflowVersion;
+ const launchPlansPromise = listLaunchPlans(
+ { project, domain },
+ {
+ filter: [
+ {
+ key: 'workflow.name',
+ operation: FilterOperationName.EQ,
+ value: name
+ },
+ {
+ key: 'workflow.version',
+ operation: FilterOperationName.EQ,
+ value: version
+ }
+ ],
+ limit: 10
+ }
+ );
+
+ const [launchPlansResult, preferredLaunchPlanResult] = await Promise.all([
+ launchPlansPromise,
+ preferredLaunchPlanPromise
+ ]);
+ const merged = [
+ ...launchPlansResult.entities,
+ ...preferredLaunchPlanResult.entities
+ ];
+ return uniqBy(merged, ({ id }) => id.name);
+}
+
+async function loadWorkflowVersions(
+ { listWorkflows }: APIContextValue,
+ { preferredWorkflowId, sourceId: sourceWorkflowName }: WorkflowLaunchContext
+) {
+ if (!sourceWorkflowName) {
+ throw new Error('Cannot load workflows, missing workflowName');
+ }
+ const { project, domain, name } = sourceWorkflowName;
+ const workflowsPromise = listWorkflows(
+ { project, domain, name },
+ {
+ limit: 10,
+ sort: {
+ key: workflowSortFields.createdAt,
+ direction: SortDirection.DESCENDING
+ }
+ }
+ );
+
+ let preferredWorkflowPromise = Promise.resolve({
+ entities: [] as Workflow[]
+ });
+ if (preferredWorkflowId) {
+ const { version, ...scope } = preferredWorkflowId;
+ preferredWorkflowPromise = listWorkflows(scope, {
+ limit: 1,
+ filter: [
+ {
+ key: 'version',
+ operation: FilterOperationName.EQ,
+ value: version
+ }
+ ]
+ });
+ }
+
+ const [workflowsResult, preferredWorkflowResult] = await Promise.all([
+ workflowsPromise,
+ preferredWorkflowPromise
+ ]);
+ const merged = [
+ ...workflowsResult.entities,
+ ...preferredWorkflowResult.entities
+ ];
+ return uniqBy(merged, ({ id: { version } }) => version);
+}
+
+async function loadInputs(
+ { getWorkflow }: APIContextValue,
+ { defaultInputValues, workflowVersion, launchPlan }: WorkflowLaunchContext
+) {
+ if (!workflowVersion) {
+ throw new Error('Failed to load inputs: missing workflowVersion');
+ }
+ if (!launchPlan) {
+ throw new Error('Failed to load inputs: missing launchPlan');
+ }
+ const workflow = await getWorkflow(workflowVersion);
+ const parsedInputs: ParsedInput[] = getInputsForWorkflow(
+ workflow,
+ launchPlan,
+ defaultInputValues
+ );
+
+ return {
+ parsedInputs,
+ unsupportedRequiredInputs: getUnsupportedRequiredInputs(parsedInputs)
+ };
+}
+
+async function submit(
+ { createWorkflowExecution }: APIContextValue,
+ formInputsRef: RefObject,
+ { launchPlan, referenceExecutionId, workflowVersion }: WorkflowLaunchContext
+) {
+ if (!launchPlan) {
+ throw new Error('Attempting to launch with no LaunchPlan');
+ }
+ if (!workflowVersion) {
+ throw new Error('Attempting to launch with no Workflow version');
+ }
+ if (formInputsRef.current === null) {
+ throw new Error('Unexpected empty form inputs ref');
+ }
+ const literals = formInputsRef.current.getValues();
+ const launchPlanId = launchPlan.id;
+ const { domain, project } = workflowVersion;
+
+ const response = await createWorkflowExecution({
+ domain,
+ launchPlanId,
+ project,
+ referenceExecutionId,
+ inputs: { literals }
+ });
+ const newExecutionId = response.id as WorkflowExecutionIdentifier;
+ if (!newExecutionId) {
+ throw new Error('API Response did not include new execution id');
+ }
+
+ return newExecutionId;
+}
+
+function getServices(
+ apiContext: APIContextValue,
+ formInputsRef: RefObject
+) {
+ return {
+ loadWorkflowVersions: partial(loadWorkflowVersions, apiContext),
+ loadLaunchPlans: partial(loadLaunchPlans, apiContext),
+ loadInputs: partial(loadInputs, apiContext),
+ submit: partial(submit, apiContext, formInputsRef),
+ validate: partial(validate, formInputsRef)
+ };
+}
+
+/** Contains all of the form state for a LaunchWorkflowForm, including input
+ * definitions, current input values, and errors.
+ */
+export function useLaunchWorkflowFormState({
+ initialParameters = {},
+ workflowId: sourceId,
+ referenceExecutionId
+}: LaunchWorkflowFormProps): LaunchWorkflowFormState {
+ // These values will be used to auto-select items from the workflow
+ // version/launch plan drop downs.
+ const {
+ launchPlan: preferredLaunchPlanId,
+ workflowId: preferredWorkflowId,
+ values: defaultInputValues
+ } = initialParameters;
+
+ const apiContext = useAPIContext();
+ const formInputsRef = useRef(null);
+
+ const services = useMemo(() => getServices(apiContext, formInputsRef), [
+ apiContext,
+ formInputsRef
+ ]);
+
+ const [state, sendEvent, service] = useMachine<
+ WorkflowLaunchContext,
+ WorkflowLaunchEvent,
+ WorkflowLaunchTypestate
+ >(workflowLaunchMachine, {
+ ...defaultStateMachineConfig,
+ services,
+ context: {
+ defaultInputValues,
+ preferredLaunchPlanId,
+ preferredWorkflowId,
+ referenceExecutionId,
+ sourceId
+ }
+ });
+
+ const {
+ launchPlanOptions = [],
+ launchPlan,
+ workflowVersionOptions = [],
+ workflowVersion
+ } = state.context;
+
+ const selectWorkflowVersion = (newWorkflow: WorkflowId) => {
+ if (newWorkflow === workflowVersion) {
+ return;
+ }
+ sendEvent({
+ type: 'SELECT_WORKFLOW_VERSION',
+ workflowId: newWorkflow
+ });
+ };
+
+ const selectLaunchPlan = (newLaunchPlan: LaunchPlan) => {
+ if (newLaunchPlan === launchPlan) {
+ return;
+ }
+ sendEvent({
+ type: 'SELECT_LAUNCH_PLAN',
+ launchPlan: newLaunchPlan
+ });
+ };
+
+ const workflowSourceSelectorState = useWorkflowSourceSelectorState({
+ launchPlan,
+ launchPlanOptions,
+ sourceId,
+ selectLaunchPlan,
+ selectWorkflowVersion,
+ workflowVersion,
+ workflowVersionOptions
+ });
+
+ useEffect(() => {
+ const subscription = service.subscribe(newState => {
+ if (newState.matches(LaunchState.SELECT_WORKFLOW_VERSION)) {
+ const {
+ workflowVersionOptions,
+ preferredWorkflowId
+ } = newState.context;
+ if (workflowVersionOptions.length > 0) {
+ let workflowToSelect = workflowVersionOptions[0];
+ if (preferredWorkflowId) {
+ const preferred = workflowVersionOptions.find(
+ ({ id }) => isEqual(id, preferredWorkflowId)
+ );
+ if (preferred) {
+ workflowToSelect = preferred;
+ }
+ }
+ sendEvent({
+ type: 'SELECT_WORKFLOW_VERSION',
+ workflowId: workflowToSelect.id
+ });
+ }
+ }
+
+ if (newState.matches(LaunchState.SELECT_LAUNCH_PLAN)) {
+ const {
+ launchPlan,
+ launchPlanOptions,
+ sourceId
+ } = newState.context;
+ if (!launchPlanOptions.length) {
+ return;
+ }
+
+ let launchPlanToSelect = launchPlanOptions[0];
+ /* Attempt to select, in order:
+ * 1. The last launch plan that was selected, matching by the name, to preserve
+ * any user selection before switching workflow versions.
+ * 2. The launch plan that was specified when initializing the form, by full id
+ * 3. The default launch plan, which has the same `name` as the workflow
+ * 4. The first launch plan in the list
+ */
+ if (launchPlan) {
+ const lastSelected = launchPlanOptions.find(
+ ({ id: { name } }) => name === launchPlan.id.name
+ );
+ if (lastSelected) {
+ launchPlanToSelect = lastSelected;
+ }
+ } else if (preferredLaunchPlanId) {
+ const preferred = launchPlanOptions.find(({ id }) =>
+ isEqual(id, preferredLaunchPlanId)
+ );
+ if (preferred) {
+ launchPlanToSelect = preferred;
+ }
+ } else {
+ const defaultLaunchPlan = launchPlanOptions.find(
+ ({ id: { name } }) => name === sourceId.name
+ );
+ if (defaultLaunchPlan) {
+ launchPlanToSelect = defaultLaunchPlan;
+ }
+ }
+
+ sendEvent({
+ type: 'SELECT_LAUNCH_PLAN',
+ launchPlan: launchPlanToSelect
+ });
+ }
+ });
+
+ return subscription.unsubscribe;
+ }, [service, sendEvent]);
+
+ return {
+ formInputsRef,
+ state,
+ service,
+ workflowSourceSelectorState
+ };
+}
diff --git a/src/components/Launch/LaunchForm/useMappedExecutionInputValues.ts b/src/components/Launch/LaunchForm/useMappedExecutionInputValues.ts
new file mode 100644
index 000000000..e4e8688c9
--- /dev/null
+++ b/src/components/Launch/LaunchForm/useMappedExecutionInputValues.ts
@@ -0,0 +1,61 @@
+import { log } from 'common/log';
+import { APIContextValue, useAPIContext } from 'components/data/apiContext';
+import { fetchWorkflowExecutionInputs } from 'components/Executions/useWorkflowExecution';
+import { FetchableData, useFetchableData } from 'components/hooks';
+import { Execution, Variable } from 'models';
+import { LiteralValueMap } from './types';
+import { createInputCacheKey, getInputDefintionForLiteralType } from './utils';
+
+export interface UseMappedExecutionInputValuesArgs {
+ execution: Execution;
+ inputDefinitions: Record;
+}
+
+export async function fetchAndMapExecutionInputValues(
+ { execution, inputDefinitions }: UseMappedExecutionInputValuesArgs,
+ apiContext: APIContextValue
+): Promise {
+ const inputValues = await fetchWorkflowExecutionInputs(
+ execution,
+ apiContext
+ );
+
+ const { literals } = inputValues;
+ const values: LiteralValueMap = Object.keys(literals).reduce(
+ (out, name) => {
+ const input = inputDefinitions[name];
+ if (!input) {
+ log.error(`Unexpected missing input definition: ${name}`);
+ return out;
+ }
+ const typeDefinition = getInputDefintionForLiteralType(input.type);
+
+ const key = createInputCacheKey(name, typeDefinition);
+ out.set(key, literals[name]);
+ return out;
+ },
+ new Map()
+ );
+ return values;
+}
+
+/** Returns a fetchable that will result in a LiteralValueMap representing the
+ * input values from an execution mapped to a set of input definitions from a Task or Workflow */
+export function useMappedExecutionInputValues({
+ execution,
+ inputDefinitions
+}: UseMappedExecutionInputValuesArgs): FetchableData {
+ const apiContext = useAPIContext();
+ return useFetchableData(
+ {
+ debugName: 'MappedExecutionInputValues',
+ defaultValue: {} as LiteralValueMap,
+ doFetch: async ({ execution, inputDefinitions }) =>
+ fetchAndMapExecutionInputValues(
+ { execution, inputDefinitions },
+ apiContext
+ )
+ },
+ { execution, inputDefinitions }
+ );
+}
diff --git a/src/components/Launch/LaunchForm/useTaskSourceSelectorState.ts b/src/components/Launch/LaunchForm/useTaskSourceSelectorState.ts
new file mode 100644
index 000000000..bc8ca04bc
--- /dev/null
+++ b/src/components/Launch/LaunchForm/useTaskSourceSelectorState.ts
@@ -0,0 +1,100 @@
+import { APIContextValue, useAPIContext } from 'components/data/apiContext';
+import {
+ FilterOperationName,
+ Identifier,
+ NamedEntityIdentifier,
+ SortDirection,
+ Task,
+ taskSortFields
+} from 'models';
+import { useMemo, useState } from 'react';
+import { SearchableSelectorOption } from './SearchableSelector';
+import { TaskSourceSelectorState } from './types';
+import { useVersionSelectorOptions } from './useVersionSelectorOptions';
+import { versionsToSearchableSelectorOptions } from './utils';
+
+function generateFetchSearchResults(
+ { listTasks }: APIContextValue,
+ taskId: NamedEntityIdentifier
+) {
+ return async (query: string) => {
+ const { project, domain, name } = taskId;
+ const { entities: tasks } = await listTasks(
+ { project, domain, name },
+ {
+ filter: [
+ {
+ key: 'version',
+ operation: FilterOperationName.CONTAINS,
+ value: query
+ }
+ ],
+ sort: {
+ key: taskSortFields.createdAt,
+ direction: SortDirection.DESCENDING
+ }
+ }
+ );
+ return versionsToSearchableSelectorOptions(tasks);
+ };
+}
+
+interface UseTaskSourceSelectorStateArgs {
+ /** The parent task for which we are selecting a version. */
+ sourceId: NamedEntityIdentifier;
+ /** The currently selected Task version. */
+ taskVersion?: Identifier;
+ /** The list of options to show for the Task selector. */
+ taskVersionOptions: Task[];
+ /** Callback fired when a task has been selected. */
+ selectTaskVersion(task: Identifier): void;
+}
+
+/** Generates state for the version selector rendered when using a task
+ * as a source in the Launch form.
+ */
+export function useTaskSourceSelectorState({
+ sourceId,
+ taskVersion,
+ taskVersionOptions,
+ selectTaskVersion
+}: UseTaskSourceSelectorStateArgs): TaskSourceSelectorState {
+ const apiContext = useAPIContext();
+ const taskSelectorOptions = useVersionSelectorOptions(taskVersionOptions);
+ const [taskVersionSearchOptions, setTaskVersionSearchOptions] = useState<
+ SearchableSelectorOption[]
+ >([]);
+
+ const selectedTask = useMemo(() => {
+ if (!taskVersion) {
+ return undefined;
+ }
+ // Search both the default and search results to match our selected task
+ // with the correct SearchableSelector item.
+ return [...taskSelectorOptions, ...taskVersionSearchOptions].find(
+ option => option.id === taskVersion.version
+ );
+ }, [taskVersion, taskVersionOptions]);
+
+ const onSelectTaskVersion = useMemo(
+ () => ({ data }: SearchableSelectorOption) =>
+ selectTaskVersion(data),
+ [selectTaskVersion]
+ );
+
+ const fetchSearchResults = useMemo(() => {
+ const doFetch = generateFetchSearchResults(apiContext, sourceId);
+ return async (query: string) => {
+ const results = await doFetch(query);
+ setTaskVersionSearchOptions(results);
+ return results;
+ };
+ }, [apiContext, sourceId, setTaskVersionSearchOptions]);
+
+ return {
+ fetchSearchResults,
+ onSelectTaskVersion,
+ selectedTask,
+ taskSelectorOptions
+ };
+}
diff --git a/src/components/Launch/LaunchForm/useVersionSelectorOptions.ts b/src/components/Launch/LaunchForm/useVersionSelectorOptions.ts
new file mode 100644
index 000000000..f7ee0f00a
--- /dev/null
+++ b/src/components/Launch/LaunchForm/useVersionSelectorOptions.ts
@@ -0,0 +1,13 @@
+import { useMemo } from 'react';
+import { SearchableVersion } from './types';
+import { versionsToSearchableSelectorOptions } from './utils';
+
+export function useVersionSelectorOptions(versions: SearchableVersion[]) {
+ return useMemo(() => {
+ const options = versionsToSearchableSelectorOptions(versions);
+ if (options.length > 0) {
+ options[0].description = 'latest';
+ }
+ return options;
+ }, [versions]);
+}
diff --git a/src/components/Launch/LaunchForm/useWorkflowSourceSelectorState.ts b/src/components/Launch/LaunchForm/useWorkflowSourceSelectorState.ts
new file mode 100644
index 000000000..e607599be
--- /dev/null
+++ b/src/components/Launch/LaunchForm/useWorkflowSourceSelectorState.ts
@@ -0,0 +1,143 @@
+import { APIContextValue, useAPIContext } from 'components/data/apiContext';
+import {
+ FilterOperationName,
+ LaunchPlan,
+ NamedEntityIdentifier,
+ SortDirection,
+ Workflow,
+ WorkflowId,
+ workflowSortFields
+} from 'models';
+import { useMemo, useState } from 'react';
+import { SearchableSelectorOption } from './SearchableSelector';
+import { WorkflowSourceSelectorState } from './types';
+import { useVersionSelectorOptions } from './useVersionSelectorOptions';
+import {
+ launchPlansToSearchableSelectorOptions,
+ versionsToSearchableSelectorOptions
+} from './utils';
+
+function useLaunchPlanSelectorOptions(launchPlans: LaunchPlan[]) {
+ return useMemo(() => launchPlansToSearchableSelectorOptions(launchPlans), [
+ launchPlans
+ ]);
+}
+
+function generateFetchSearchResults(
+ { listWorkflows }: APIContextValue,
+ workflowId: NamedEntityIdentifier
+) {
+ return async (query: string) => {
+ const { project, domain, name } = workflowId;
+ const { entities: workflows } = await listWorkflows(
+ { project, domain, name },
+ {
+ filter: [
+ {
+ key: 'version',
+ operation: FilterOperationName.CONTAINS,
+ value: query
+ }
+ ],
+ sort: {
+ key: workflowSortFields.createdAt,
+ direction: SortDirection.DESCENDING
+ }
+ }
+ );
+ return versionsToSearchableSelectorOptions(workflows);
+ };
+}
+
+interface UseWorkflowSourceSelectorStateArgs {
+ /** The currently selected launch plan */
+ launchPlan?: LaunchPlan;
+ /** List of options to show for the launch plan selector. */
+ launchPlanOptions: LaunchPlan[];
+ /** The parent workflow for which we are selecting a version. */
+ sourceId: NamedEntityIdentifier;
+ /** The currently selected Workflow version. */
+ workflowVersion?: WorkflowId;
+ /** The list of options to show for the Workflow selector. */
+ workflowVersionOptions: Workflow[];
+ /** Callback fired when a workflow has been selected. */
+ selectWorkflowVersion(workflow: WorkflowId): void;
+ /** Callback fired when a launch plan has been selected. */
+ selectLaunchPlan(launchPlan: LaunchPlan): void;
+}
+
+/** Generates state for the workflow/launch plan selectors render when using a workflow
+ * as a source in the Launch form.
+ */
+export function useWorkflowSourceSelectorState({
+ launchPlan,
+ launchPlanOptions,
+ sourceId,
+ workflowVersion,
+ workflowVersionOptions,
+ selectLaunchPlan,
+ selectWorkflowVersion
+}: UseWorkflowSourceSelectorStateArgs): WorkflowSourceSelectorState {
+ const apiContext = useAPIContext();
+ const workflowSelectorOptions = useVersionSelectorOptions(
+ workflowVersionOptions
+ );
+ const [
+ workflowVersionSearchOptions,
+ setWorkflowVersionSearchOptions
+ ] = useState[]>([]);
+ const launchPlanSelectorOptions = useLaunchPlanSelectorOptions(
+ launchPlanOptions
+ );
+
+ const selectedWorkflow = useMemo(() => {
+ if (!workflowVersion) {
+ return undefined;
+ }
+ // Search both the default and search results to match our selected workflow
+ // with the correct SearchableSelector item.
+ return [
+ ...workflowSelectorOptions,
+ ...workflowVersionSearchOptions
+ ].find(option => option.id === workflowVersion.version);
+ }, [workflowVersion, workflowVersionOptions]);
+
+ const selectedLaunchPlan = useMemo(() => {
+ if (!launchPlan) {
+ return undefined;
+ }
+ return launchPlanSelectorOptions.find(
+ option => option.id === launchPlan.id.name
+ );
+ }, [launchPlan, launchPlanOptions]);
+
+ const onSelectLaunchPlan = useMemo(
+ () => ({ data }: SearchableSelectorOption) =>
+ selectLaunchPlan(data),
+ [selectLaunchPlan]
+ );
+ const onSelectWorkflowVersion = useMemo(
+ () => ({ data }: SearchableSelectorOption) =>
+ selectWorkflowVersion(data),
+ [selectWorkflowVersion]
+ );
+
+ const fetchSearchResults = useMemo(() => {
+ const doFetch = generateFetchSearchResults(apiContext, sourceId);
+ return async (query: string) => {
+ const results = await doFetch(query);
+ setWorkflowVersionSearchOptions(results);
+ return results;
+ };
+ }, [apiContext, sourceId, setWorkflowVersionSearchOptions]);
+
+ return {
+ fetchSearchResults,
+ launchPlanSelectorOptions,
+ onSelectLaunchPlan,
+ onSelectWorkflowVersion,
+ selectedLaunchPlan,
+ selectedWorkflow,
+ workflowSelectorOptions
+ };
+}
diff --git a/src/components/Launch/LaunchWorkflowForm/utils.ts b/src/components/Launch/LaunchForm/utils.ts
similarity index 82%
rename from src/components/Launch/LaunchWorkflowForm/utils.ts
rename to src/components/Launch/LaunchForm/utils.ts
index 2434b0210..ba1111dbd 100644
--- a/src/components/Launch/LaunchWorkflowForm/utils.ts
+++ b/src/components/Launch/LaunchForm/utils.ts
@@ -2,11 +2,12 @@ import { timestampToDate } from 'common/utils';
import { Core } from 'flyteidl';
import { isObject } from 'lodash';
import {
+ Identifier,
LaunchPlan,
LiteralType,
+ Task,
Variable,
- Workflow,
- WorkflowId
+ Workflow
} from 'models';
import * as moment from 'moment';
import { simpleTypeToInputType, typeLabels } from './constants';
@@ -18,7 +19,8 @@ import {
InputProps,
InputType,
InputTypeDefinition,
- ParsedInput
+ ParsedInput,
+ SearchableVersion
} from './types';
/** Creates a unique cache key for an input based on its name and type.
@@ -56,6 +58,25 @@ export function getWorkflowInputs(
return inputs.variables;
}
+export function getTaskInputs(task: Task): Record {
+ if (!task.closure) {
+ return {};
+ }
+ const { compiledTask } = task.closure;
+ if (!compiledTask) {
+ return {};
+ }
+ const { interface: ioInterface } = compiledTask.template;
+ if (!ioInterface) {
+ return {};
+ }
+ const { inputs } = ioInterface;
+ if (!inputs) {
+ return {};
+ }
+ return inputs.variables;
+}
+
/** Returns a formatted string based on an InputTypeDefinition.
* ex. `string`, `string[]`, `map`
*/
@@ -77,17 +98,17 @@ export function formatLabelWithType(label: string, type: InputTypeDefinition) {
return `${label}${typeString ? ` (${typeString})` : ''}`;
}
-/** Formats a list of `Workflow` records for use in a `SearchableSelector` */
-export function workflowsToSearchableSelectorOptions(
- workflows: Workflow[]
-): SearchableSelectorOption[] {
- return workflows.map>((wf, index) => ({
- data: wf.id,
- id: wf.id.version,
- name: wf.id.version,
+/** Formats a list of records for use in a `SearchableSelector` */
+export function versionsToSearchableSelectorOptions(
+ items: SearchableVersion[]
+): SearchableSelectorOption[] {
+ return items.map>((item, index) => ({
+ data: item.id,
+ id: item.id.version,
+ name: item.id.version,
description:
- wf.closure && wf.closure.createdAt
- ? moment(timestampToDate(wf.closure.createdAt)).format(
+ item.closure && item.closure.createdAt
+ ? moment(timestampToDate(item.closure.createdAt)).format(
'DD MMM YYYY'
)
: ''
diff --git a/src/components/Launch/LaunchWorkflowForm/LaunchWorkflowForm.tsx b/src/components/Launch/LaunchWorkflowForm/LaunchWorkflowForm.tsx
deleted file mode 100644
index a89b89d50..000000000
--- a/src/components/Launch/LaunchWorkflowForm/LaunchWorkflowForm.tsx
+++ /dev/null
@@ -1,161 +0,0 @@
-import {
- Button,
- DialogActions,
- DialogContent,
- DialogTitle,
- FormHelperText,
- Typography
-} from '@material-ui/core';
-import { WaitForData } from 'components/common';
-import { ButtonCircularProgress } from 'components/common/ButtonCircularProgress';
-import { APIContextValue, useAPIContext } from 'components/data/apiContext';
-import { isLoadingState } from 'components/hooks/fetchMachine';
-import {
- FilterOperationName,
- NamedEntityIdentifier,
- SortDirection,
- workflowSortFields
-} from 'models';
-import * as React from 'react';
-import { formStrings } from './constants';
-import { InputValueCacheContext } from './inputValueCache';
-import { LaunchWorkflowFormInputs } from './LaunchWorkflowFormInputs';
-import { SearchableSelector } from './SearchableSelector';
-import { useStyles } from './styles';
-import { LaunchWorkflowFormProps } from './types';
-import { UnsupportedRequiredInputsError } from './UnsupportedRequiredInputsError';
-import { useLaunchWorkflowFormState } from './useLaunchWorkflowFormState';
-import { workflowsToSearchableSelectorOptions } from './utils';
-
-function generateFetchSearchResults(
- { listWorkflows }: APIContextValue,
- workflowId: NamedEntityIdentifier
-) {
- return async (query: string) => {
- const { project, domain, name } = workflowId;
- const { entities: workflows } = await listWorkflows(
- { project, domain, name },
- {
- filter: [
- {
- key: 'version',
- operation: FilterOperationName.CONTAINS,
- value: query
- }
- ],
- sort: {
- key: workflowSortFields.createdAt,
- direction: SortDirection.DESCENDING
- }
- }
- );
- return workflowsToSearchableSelectorOptions(workflows);
- };
-}
-
-/** Renders the form for initiating a Launch request based on a Workflow */
-export const LaunchWorkflowForm: React.FC = props => {
- const state = useLaunchWorkflowFormState(props);
- const { submissionState, unsupportedRequiredInputs, workflows } = state;
- const styles = useStyles();
- const fetchSearchResults = generateFetchSearchResults(
- useAPIContext(),
- props.workflowId
- );
-
- const submit: React.FormEventHandler = event => {
- event.preventDefault();
- state.onSubmit();
- };
-
- const submissionInFlight = isLoadingState(submissionState.state);
- const preventSubmit =
- submissionInFlight ||
- !state.inputsReady ||
- unsupportedRequiredInputs.length > 0;
-
- return (
-
-
-
{formStrings.title}
- {state.workflowName}
-
-
-
-
-
-
-
- {state.inputsReady ? (
-
- {state.unsupportedRequiredInputs.length > 0 ? (
-
- ) : (
-
- )}
-
- ) : null}
-
-
-
- {!!submissionState.lastError && (
-
- {submissionState.lastError.message}
-
- )}
-
-
-
-
-
-
- );
-};
diff --git a/src/components/Launch/LaunchWorkflowForm/LaunchWorkflowFormInputs.tsx b/src/components/Launch/LaunchWorkflowForm/LaunchWorkflowFormInputs.tsx
deleted file mode 100644
index ad83ed0ab..000000000
--- a/src/components/Launch/LaunchWorkflowForm/LaunchWorkflowFormInputs.tsx
+++ /dev/null
@@ -1,65 +0,0 @@
-import * as React from 'react';
-import { BlobInput } from './BlobInput';
-import { CollectionInput } from './CollectionInput';
-import { SimpleInput } from './SimpleInput';
-import { useStyles } from './styles';
-import {
- InputProps,
- InputType,
- LaunchWorkflowFormInputsRef,
- ParsedInput
-} from './types';
-import { UnsupportedInput } from './UnsupportedInput';
-import { useFormInputsState } from './useFormInputsState';
-
-function getComponentForInput(input: InputProps, showErrors: boolean) {
- const props = { ...input, error: showErrors ? input.error : undefined };
- switch (input.typeDefinition.type) {
- case InputType.Blob:
- return ;
- case InputType.Collection:
- return ;
- case InputType.Map:
- case InputType.Schema:
- case InputType.Unknown:
- case InputType.None:
- return ;
- default:
- return ;
- }
-}
-
-export interface LaunchWorkflowFormInputsProps {
- inputs: ParsedInput[];
- showErrors?: boolean;
-}
-
-export const LaunchWorkflowFormInputsImpl: React.RefForwardingComponent<
- LaunchWorkflowFormInputsRef,
- LaunchWorkflowFormInputsProps
-> = ({ inputs: parsedInputs, showErrors = true }, ref) => {
- const { getValues, inputs, validate } = useFormInputsState(parsedInputs);
- const styles = useStyles();
- React.useImperativeHandle(ref, () => ({
- getValues,
- validate
- }));
-
- return (
- <>
- {inputs.map(input => (
-
- {getComponentForInput(input, showErrors)}
-
- ))}
-
- );
-};
-
-/** Renders an array of `ParsedInput` values using the appropriate
- * components. A `ref` to this component is used to access the current
- * form values and trigger manual validation if needed.
- */
-export const LaunchWorkflowFormInputs = React.forwardRef(
- LaunchWorkflowFormInputsImpl
-);
diff --git a/src/components/Launch/LaunchWorkflowForm/types.ts b/src/components/Launch/LaunchWorkflowForm/types.ts
deleted file mode 100644
index f4a1334e1..000000000
--- a/src/components/Launch/LaunchWorkflowForm/types.ts
+++ /dev/null
@@ -1,113 +0,0 @@
-import { FetchableData } from 'components/hooks';
-import { Core } from 'flyteidl';
-import {
- BlobDimensionality,
- Identifier,
- LaunchPlan,
- NamedEntityIdentifier,
- Workflow,
- WorkflowExecutionIdentifier,
- WorkflowId
-} from 'models';
-import { SearchableSelectorOption } from './SearchableSelector';
-
-export type InputValueMap = Map;
-export type LiteralValueMap = Map;
-
-export interface InitialLaunchParameters {
- launchPlan?: Identifier;
- workflow?: WorkflowId;
- values?: LiteralValueMap;
-}
-
-export interface LaunchWorkflowFormProps {
- workflowId: NamedEntityIdentifier;
- initialParameters?: InitialLaunchParameters;
- onClose(): void;
-}
-
-export interface LaunchWorkflowFormInputsRef {
- getValues(): Record;
- validate(): boolean;
-}
-
-export interface LaunchWorkflowFormState {
- /** Used to key inputs component so it is re-mounted the list of inputs */
- formKey?: string;
- formInputsRef: React.RefObject;
- inputs: ParsedInput[];
- inputsReady: boolean;
- inputValueCache: InputValueMap;
- launchPlans: FetchableData;
- launchPlanSelectorOptions: SearchableSelectorOption[];
- selectedLaunchPlan?: SearchableSelectorOption;
- selectedWorkflow?: SearchableSelectorOption;
- showErrors: boolean;
- submissionState: FetchableData;
- unsupportedRequiredInputs: ParsedInput[];
- workflowName: string;
- workflows: FetchableData;
- workflowSelectorOptions: SearchableSelectorOption[];
- onCancel(): void;
- onSelectWorkflow(selected: SearchableSelectorOption): void;
- onSubmit(): void;
- onSelectLaunchPlan(selected: SearchableSelectorOption): void;
-}
-
-export enum InputType {
- Binary = 'BINARY',
- Blob = 'BLOB',
- Boolean = 'BOOLEAN',
- Collection = 'COLLECTION',
- Datetime = 'DATETIME',
- Duration = 'DURATION',
- Error = 'ERROR',
- Float = 'FLOAT',
- Integer = 'INTEGER',
- Map = 'MAP',
- None = 'NONE',
- Schema = 'SCHEMA',
- String = 'STRING',
- Struct = 'STRUCT',
- Unknown = 'UNKNOWN'
-}
-
-export interface InputTypeDefinition {
- type: InputType;
- subtype?: InputTypeDefinition;
-}
-
-export interface ObjectValue {
- type: InputType;
-}
-
-export interface BlobValue {
- dimensionality: BlobDimensionality | string;
- format?: string;
- uri: string;
-}
-
-export type InputValue = string | number | boolean | Date | BlobValue;
-export type InputChangeHandler = (newValue: InputValue) => void;
-
-export interface InputProps {
- description: string;
- error?: string;
- helperText?: string;
- initialValue?: Core.ILiteral;
- name: string;
- label: string;
- required: boolean;
- typeDefinition: InputTypeDefinition;
- value?: InputValue;
- onChange: InputChangeHandler;
-}
-
-export interface ParsedInput
- extends Pick<
- InputProps,
- 'description' | 'label' | 'name' | 'required' | 'typeDefinition'
- > {
- /** Provides an initial value for the input, which can be changed by the user. */
- initialValue?: Core.ILiteral;
-}
diff --git a/src/components/Launch/LaunchWorkflowForm/useExecutionLaunchConfiguration.ts b/src/components/Launch/LaunchWorkflowForm/useExecutionLaunchConfiguration.ts
deleted file mode 100644
index 6ebf81d62..000000000
--- a/src/components/Launch/LaunchWorkflowForm/useExecutionLaunchConfiguration.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-import { log } from 'common/log';
-import { useAPIContext } from 'components/data/apiContext';
-import { fetchWorkflowExecutionInputs } from 'components/Executions/useWorkflowExecution';
-import { FetchableData, useFetchableData } from 'components/hooks';
-import { Execution, Variable } from 'models';
-import { InitialLaunchParameters, LiteralValueMap } from './types';
-import { createInputCacheKey, getInputDefintionForLiteralType } from './utils';
-
-export interface UseExecutionLaunchConfigurationArgs {
- execution: Execution;
- workflowInputs: Record;
-}
-
-/** Returns a fetchable that will result in a `InitialLaunchParameters` object based on a provided `Execution` and its associated workflow inputs. */
-export function useExecutionLaunchConfiguration({
- execution,
- workflowInputs
-}: UseExecutionLaunchConfigurationArgs): FetchableData<
- InitialLaunchParameters
-> {
- const apiContext = useAPIContext();
- return useFetchableData<
- InitialLaunchParameters,
- UseExecutionLaunchConfigurationArgs
- >(
- {
- debugName: 'ExecutionLaunchConfiguration',
- defaultValue: {} as InitialLaunchParameters,
- doFetch: async ({ execution, workflowInputs }) => {
- const {
- closure: { workflowId },
- spec: { launchPlan }
- } = execution;
-
- const inputs = await fetchWorkflowExecutionInputs(
- execution,
- apiContext
- );
-
- const { literals } = inputs;
- const values: LiteralValueMap = Object.keys(literals).reduce(
- (out, name) => {
- const workflowInput = workflowInputs[name];
- if (!workflowInput) {
- log.error(
- `Unexpected missing workflow input: ${name}`
- );
- return out;
- }
- const typeDefinition = getInputDefintionForLiteralType(
- workflowInput.type
- );
-
- const key = createInputCacheKey(name, typeDefinition);
- out.set(key, literals[name]);
- return out;
- },
- new Map()
- );
-
- return { launchPlan, values, workflow: workflowId };
- }
- },
- { execution, workflowInputs }
- );
-}
diff --git a/src/components/Launch/LaunchWorkflowForm/useLaunchWorkflowFormState.ts b/src/components/Launch/LaunchWorkflowForm/useLaunchWorkflowFormState.ts
deleted file mode 100644
index c21b54e17..000000000
--- a/src/components/Launch/LaunchWorkflowForm/useLaunchWorkflowFormState.ts
+++ /dev/null
@@ -1,430 +0,0 @@
-import { getCacheKey } from 'components/Cache';
-import { useAPIContext } from 'components/data/apiContext';
-import { useFetchableData, useWorkflow } from 'components/hooks';
-import { fetchStates } from 'components/hooks/types';
-import { isEqual, uniqBy } from 'lodash';
-import {
- FilterOperationName,
- Identifier,
- LaunchPlan,
- NamedEntityIdentifier,
- SortDirection,
- Workflow,
- WorkflowExecutionIdentifier,
- WorkflowId,
- workflowSortFields
-} from 'models';
-import { useEffect, useMemo, useRef, useState } from 'react';
-import { history, Routes } from 'routes';
-import { getInputs } from './getInputs';
-import { createInputValueCache } from './inputValueCache';
-import { SearchableSelectorOption } from './SearchableSelector';
-import {
- LaunchWorkflowFormInputsRef,
- LaunchWorkflowFormProps,
- LaunchWorkflowFormState,
- ParsedInput
-} from './types';
-import {
- getUnsupportedRequiredInputs,
- launchPlansToSearchableSelectorOptions,
- workflowsToSearchableSelectorOptions
-} from './utils';
-
-export function useWorkflowSelectorOptions(workflows: Workflow[]) {
- return useMemo(() => {
- const options = workflowsToSearchableSelectorOptions(workflows);
- if (options.length > 0) {
- options[0].description = 'latest';
- }
- return options;
- }, [workflows]);
-}
-
-function useLaunchPlanSelectorOptions(launchPlans: LaunchPlan[]) {
- return useMemo(() => launchPlansToSearchableSelectorOptions(launchPlans), [
- launchPlans
- ]);
-}
-
-interface UseLaunchPlansForWorkflowArgs {
- workflowId?: WorkflowId | null;
- preferredLaunchPlanId?: Identifier;
-}
-/** Lists launch plans for a given workflowId, optionally fetching a preferred
- * launch plan. The result is a merged, de-duplicated list.
- */
-function useLaunchPlansForWorkflow({
- workflowId = null,
- preferredLaunchPlanId
-}: UseLaunchPlansForWorkflowArgs) {
- const { listLaunchPlans } = useAPIContext();
- return useFetchableData(
- {
- autoFetch: workflowId !== null,
- debugName: 'useLaunchPlansForWorkflow',
- defaultValue: [],
- doFetch: async workflowId => {
- if (workflowId === null) {
- return Promise.reject('No workflowId specified');
- }
-
- let preferredLaunchPlanPromise = Promise.resolve({
- entities: [] as LaunchPlan[]
- });
- if (preferredLaunchPlanId) {
- const { version, ...scope } = preferredLaunchPlanId;
- preferredLaunchPlanPromise = listLaunchPlans(scope, {
- limit: 1,
- filter: [
- {
- key: 'version',
- operation: FilterOperationName.EQ,
- value: version
- }
- ]
- });
- }
-
- const { project, domain, name, version } = workflowId;
- const launchPlansPromise = listLaunchPlans(
- { project, domain },
- // TODO: Only active?
- {
- filter: [
- {
- key: 'workflow.name',
- operation: FilterOperationName.EQ,
- value: name
- },
- {
- key: 'workflow.version',
- operation: FilterOperationName.EQ,
- value: version
- }
- ],
- limit: 10
- }
- );
-
- const [
- launchPlansResult,
- preferredLaunchPlanResult
- ] = await Promise.all([
- launchPlansPromise,
- preferredLaunchPlanPromise
- ]);
- const merged = [
- ...launchPlansResult.entities,
- ...preferredLaunchPlanResult.entities
- ];
- return uniqBy(merged, ({ id }) => id.name);
- }
- },
- workflowId
- );
-}
-
-/** Fetches workflow versions matching a specific scope, optionally also
- * fetching a preferred version. The result is a merged, de-duplicated list.
- */
-function useWorkflowsWithPreferredVersion(
- workflowName: NamedEntityIdentifier,
- preferredVersion?: WorkflowId
-) {
- const { listWorkflows } = useAPIContext();
- return useFetchableData(
- {
- debugName: 'UseWorkflowsWithPreferredVersion',
- defaultValue: [] as Workflow[],
- doFetch: async () => {
- const { project, domain, name } = workflowName;
- const workflowsPromise = listWorkflows(
- { project, domain, name },
- {
- limit: 10,
- sort: {
- key: workflowSortFields.createdAt,
- direction: SortDirection.DESCENDING
- }
- }
- );
-
- let preferredWorkflowPromise = Promise.resolve({
- entities: [] as Workflow[]
- });
- if (preferredVersion) {
- const { version, ...scope } = preferredVersion;
- preferredWorkflowPromise = listWorkflows(scope, {
- limit: 1,
- filter: [
- {
- key: 'version',
- operation: FilterOperationName.EQ,
- value: version
- }
- ]
- });
- }
-
- const [
- workflowsResult,
- preferredWorkflowResult
- ] = await Promise.all([
- workflowsPromise,
- preferredWorkflowPromise
- ]);
- const merged = [
- ...workflowsResult.entities,
- ...preferredWorkflowResult.entities
- ];
- return uniqBy(merged, ({ id: { version } }) => version);
- }
- },
- { workflowName, preferredVersion }
- );
-}
-
-/** Contains all of the form state for a LaunchWorkflowForm, including input
- * definitions, current input values, and errors.
- */
-export function useLaunchWorkflowFormState({
- initialParameters = {},
- onClose,
- workflowId
-}: LaunchWorkflowFormProps): LaunchWorkflowFormState {
- // These values will be used to auto-select items from the workflow
- // version/launch plan drop downs.
- const {
- launchPlan: preferredLaunchPlanId,
- workflow: preferredWorkflowId
- } = initialParameters;
-
- const { createWorkflowExecution } = useAPIContext();
- const [
- lastSelectedLaunchPlanName,
- setLastSelectedLaunchPlanName
- ] = useState();
- const formInputsRef = useRef(null);
- const [showErrors, setShowErrors] = useState(false);
- const workflows = useWorkflowsWithPreferredVersion(
- workflowId,
- preferredWorkflowId
- );
-
- const workflowSelectorOptions = useWorkflowSelectorOptions(workflows.value);
- const [selectedWorkflow, setWorkflow] = useState<
- SearchableSelectorOption
- >();
- const selectedWorkflowId = selectedWorkflow ? selectedWorkflow.data : null;
-
- const [inputValueCache] = useState(createInputValueCache());
-
- // We have to do a single item get once a workflow is selected so that we
- // receive the full workflow spec
- const workflow = useWorkflow(selectedWorkflowId);
- const launchPlans = useLaunchPlansForWorkflow({
- preferredLaunchPlanId,
- workflowId: selectedWorkflowId
- });
- const launchPlanSelectorOptions = useLaunchPlanSelectorOptions(
- launchPlans.value
- );
-
- const [selectedLaunchPlan, setLaunchPlan] = useState<
- SearchableSelectorOption
- >();
- const launchPlanData = selectedLaunchPlan
- ? selectedLaunchPlan.data
- : undefined;
-
- const [parsedInputs, setParsedInputs] = useState([]);
- const inputsReady = !!(
- launchPlanData && workflow.state.matches(fetchStates.LOADED)
- );
-
- const unsupportedRequiredInputs = useMemo(
- () => getUnsupportedRequiredInputs(parsedInputs),
- [parsedInputs]
- );
-
- // Any time the inputs change (even if it's just re-ordering), we must
- // change the form key so that the inputs component will re-mount.
- const formKey = useMemo(() => {
- if (!selectedWorkflowId || !selectedLaunchPlan) {
- return '';
- }
- return getCacheKey(parsedInputs);
- }, [parsedInputs]);
-
- // Only show errors after first submission for a set of inputs.
- useEffect(() => setShowErrors(false), [formKey]);
-
- const workflowName = workflowId.name;
-
- const onSelectWorkflow = (
- newWorkflow: SearchableSelectorOption
- ) => {
- if (newWorkflow === selectedWorkflow) {
- return;
- }
- setLaunchPlan(undefined);
- setWorkflow(newWorkflow);
- };
-
- const onSelectLaunchPlan = (
- newLaunchPlan: SearchableSelectorOption
- ) => {
- if (newLaunchPlan === selectedLaunchPlan) {
- return;
- }
- setLastSelectedLaunchPlanName(newLaunchPlan.name);
- setLaunchPlan(newLaunchPlan);
- };
-
- const launchWorkflow = async () => {
- if (!launchPlanData) {
- throw new Error('Attempting to launch with no LaunchPlan');
- }
- if (formInputsRef.current === null) {
- throw new Error('Unexpected empty form inputs ref');
- }
- const literals = formInputsRef.current.getValues();
- const launchPlanId = launchPlanData.id;
- const { domain, project } = workflowId;
-
- const response = await createWorkflowExecution({
- domain,
- launchPlanId,
- project,
- inputs: { literals }
- });
- const newExecutionId = response.id as WorkflowExecutionIdentifier;
- if (!newExecutionId) {
- throw new Error('API Response did not include new execution id');
- }
- history.push(Routes.ExecutionDetails.makeUrl(newExecutionId));
- return newExecutionId;
- };
-
- const submissionState = useFetchableData<
- WorkflowExecutionIdentifier,
- string
- >(
- {
- autoFetch: false,
- debugName: 'LaunchWorkflowForm',
- defaultValue: {} as WorkflowExecutionIdentifier,
- doFetch: launchWorkflow
- },
- formKey
- );
-
- const onSubmit = () => {
- if (formInputsRef.current === null) {
- console.error('Unexpected empty form inputs ref');
- return;
- }
-
- // Show errors after the first submission
- setShowErrors(true);
- // We validate separately so that a request isn't triggered unless
- // the inputs are valid.
- if (!formInputsRef.current.validate()) {
- return;
- }
- submissionState.fetch();
- };
- const onCancel = onClose;
-
- // Once the selected workflow and launch plan have loaded, parse and set
- // the inputs so we can render the rest of the form
- useEffect(() => {
- const parsedInputs =
- launchPlanData && workflow.state.matches(fetchStates.LOADED)
- ? getInputs(
- workflow.value,
- launchPlanData,
- initialParameters.values
- )
- : [];
- setParsedInputs(parsedInputs);
- }, [workflow.state.value, workflow.value, launchPlanData]);
-
- // Once workflows have loaded, attempt to select the preferred workflow
- // plan, or fall back to selecting the first option
- useEffect(() => {
- if (workflowSelectorOptions.length > 0 && !selectedWorkflow) {
- if (preferredWorkflowId) {
- const preferred = workflowSelectorOptions.find(({ data }) =>
- isEqual(data, preferredWorkflowId)
- );
- if (preferred) {
- setWorkflow(preferred);
- return;
- }
- }
- setWorkflow(workflowSelectorOptions[0]);
- }
- }, [workflows.value]);
-
- // Once launch plans have been loaded, attempt to keep the previously
- // selected launch plan, followed by the preferred launch plan, the one
- // matching the workflow name, or just the first option.
- useEffect(() => {
- if (!launchPlanSelectorOptions.length) {
- return;
- }
-
- if (lastSelectedLaunchPlanName) {
- const lastSelected = launchPlanSelectorOptions.find(
- ({ name }) => name === lastSelectedLaunchPlanName
- );
- if (lastSelected) {
- onSelectLaunchPlan(lastSelected);
- return;
- }
- }
-
- if (preferredLaunchPlanId) {
- const preferred = launchPlanSelectorOptions.find(
- ({ data: { id } }) => isEqual(id, preferredLaunchPlanId)
- );
- if (preferred) {
- onSelectLaunchPlan(preferred);
- return;
- }
- }
-
- const defaultLaunchPlan = launchPlanSelectorOptions.find(
- ({ id }) => id === workflowId.name
- );
- if (defaultLaunchPlan) {
- onSelectLaunchPlan(defaultLaunchPlan);
- return;
- }
- onSelectLaunchPlan(launchPlanSelectorOptions[0]);
- }, [launchPlanSelectorOptions]);
-
- return {
- formInputsRef,
- formKey,
- inputValueCache,
- inputsReady,
- launchPlans,
- launchPlanSelectorOptions,
- onCancel,
- onSelectLaunchPlan,
- onSelectWorkflow,
- onSubmit,
- selectedLaunchPlan,
- selectedWorkflow,
- showErrors,
- submissionState,
- unsupportedRequiredInputs,
- workflowName,
- workflows,
- workflowSelectorOptions,
- inputs: parsedInputs
- };
-}
diff --git a/src/components/Task/SearchableTaskNameList.tsx b/src/components/Task/SearchableTaskNameList.tsx
index ad37f0e85..4b7f5a882 100644
--- a/src/components/Task/SearchableTaskNameList.tsx
+++ b/src/components/Task/SearchableTaskNameList.tsx
@@ -1,5 +1,6 @@
import { Typography } from '@material-ui/core';
import { makeStyles, Theme } from '@material-ui/core/styles';
+import ChevronRight from '@material-ui/icons/ChevronRight';
import ErrorOutline from '@material-ui/icons/ErrorOutline';
import * as classnames from 'classnames';
import { noDescriptionString } from 'common/constants';
@@ -15,6 +16,8 @@ import { NamedEntity } from 'models';
import * as React from 'react';
import { IntersectionOptions, useInView } from 'react-intersection-observer';
import reactLoadingSkeleton from 'react-loading-skeleton';
+import { Link } from 'react-router-dom';
+import { Routes } from 'routes/routes';
import { SimpleTaskInterface } from './SimpleTaskInterface';
import { useLatestTaskVersion } from './useLatestTask';
const Skeleton = reactLoadingSkeleton;
@@ -91,6 +94,7 @@ const TaskNameRow: React.FC = ({ label, entityName }) => {
{!!inView && }