add launch all frontend functionality

js_modules/dagster-ui/packages/ui-core/src/app/Telemetry.tsx

@@ -9,6 +9,7 @@ import {gql} from '../apollo-client';
 
 export enum TelemetryAction {
   LAUNCH_RUN = 'LAUNCH_RUN',
+  LAUNCH_MULTIPLE_RUNS = 'LAUNCH_MULTIPLE_RUNS',
   GRAPHQL_QUERY_COMPLETED = 'GRAPHQL_QUERY_COMPLETED',
 }
 
@@ -38,7 +39,7 @@ const LOG_TELEMETRY_MUTATION = gql`
 export async function logTelemetry(
   pathPrefix: string,
   action: TelemetryAction,
-  metadata: {[key: string]: string | null | undefined} = {},
+  metadata: {[key: string]: string | string[] | null | undefined} = {},
 ) {
   const graphqlPath = `${pathPrefix || ''}/graphql`;
 
@@ -63,7 +64,10 @@ export async function logTelemetry(
 export const useTelemetryAction = () => {
   const {basePath, telemetryEnabled} = useContext(AppContext);
   return useCallback(
-    (action: TelemetryAction, metadata: {[key: string]: string | null | undefined} = {}) => {
+    (
+      action: TelemetryAction,
+      metadata: {[key: string]: string | string[] | null | undefined} = {},
+    ) => {
       if (telemetryEnabled) {
         logTelemetry(basePath, action, metadata);
       }

js_modules/dagster-ui/packages/ui-core/src/launchpad/useLaunchMultipleRunsWithTelemetry.ts

@@ -0,0 +1,62 @@
+import {useCallback} from 'react';
+import {useHistory} from 'react-router-dom';
+
+import {useMutation} from '../apollo-client';
+import {showLaunchError} from './showLaunchError';
+import {TelemetryAction, useTelemetryAction} from '../app/Telemetry';
+import {
+  LAUNCH_MULTIPLE_RUNS_MUTATION,
+  LaunchBehavior,
+  handleLaunchMultipleResult,
+} from '../runs/RunUtils';
+import {
+  LaunchMultipleRunsMutation,
+  LaunchMultipleRunsMutationVariables,
+} from '../runs/types/RunUtils.types';
+
+export function useLaunchMultipleRunsWithTelemetry() {
+  const [launchMultipleRuns] = useMutation<
+    LaunchMultipleRunsMutation,
+    LaunchMultipleRunsMutationVariables
+  >(LAUNCH_MULTIPLE_RUNS_MUTATION);
+
+  const logTelemetry = useTelemetryAction();
+  const history = useHistory();
+
+  return useCallback(
+    async (variables: LaunchMultipleRunsMutationVariables, behavior: LaunchBehavior) => {
+      const executionParamsList = Array.isArray(variables.executionParamsList)
+        ? variables.executionParamsList
+        : [variables.executionParamsList];
+      const jobNames = executionParamsList.map((params) => params.selector?.jobName);
+
+      if (jobNames.length !== executionParamsList.length || jobNames.includes(undefined)) {
+        return;
+      }
+
+      const metadata: {[key: string]: string | string[] | null | undefined} = {
+        jobNames: jobNames.filter((name): name is string => name !== undefined),
+        opSelection: undefined,
+      };
+
+      let result;
+      try {
+        result = (await launchMultipleRuns({variables})).data?.launchMultipleRuns;
+        if (result) {
+          handleLaunchMultipleResult(result, history, {behavior});
+          logTelemetry(
+            TelemetryAction.LAUNCH_MULTIPLE_RUNS,
+            metadata as {[key: string]: string | string[] | null | undefined},
+          );
+        }
+
+        return result;
+      } catch (error) {
+        console.error('error', error);
+        showLaunchError(error as Error);
+      }
+      return undefined;
+    },
+    [history, launchMultipleRuns, logTelemetry],
+  );
+}

js_modules/dagster-ui/packages/ui-core/src/runs/RunUtils.tsx

@@ -7,7 +7,11 @@ import {StepSelection} from './StepSelection';
 import {TimeElapsed} from './TimeElapsed';
 import {RunFragment} from './types/RunFragments.types';
 import {RunTableRunFragment} from './types/RunTableRunFragment.types';
-import {LaunchPipelineExecutionMutation, RunTimeFragment} from './types/RunUtils.types';
+import {
+  LaunchMultipleRunsMutation,
+  LaunchPipelineExecutionMutation,
+  RunTimeFragment,
+} from './types/RunUtils.types';
 import {Mono} from '../../../ui-components/src';
 import {gql} from '../apollo-client';
 import {showCustomAlert} from '../app/CustomAlertProvider';
@@ -107,14 +111,92 @@ export async function handleLaunchResult(
 
     if ('errors' in result) {
       message += ` Please fix the following errors:\n\n${result.errors
-        .map((error) => error.message)
+        .map((error: {message: any}) => error.message)
         .join('\n\n')}`;
     }
 
     showCustomAlert({body: message});
   }
 }
 
+export async function handleLaunchMultipleResult(
+  result: void | null | LaunchMultipleRunsMutation['launchMultipleRuns'],
+  history: History<unknown>,
+  options: {behavior: LaunchBehavior; preserveQuerystring?: boolean},
+) {
+  if (!result) {
+    showCustomAlert({body: `No data was returned. Did dagster-webserver crash?`});
+    return;
+  }
+  const successfulRunIds: string[] = [];
+
+  // show corresponding toasts
+  const launchMultipleRunsResult = result.launchMultipleRunsResult;
+
+  for (const individualResult of launchMultipleRunsResult) {
+    if (individualResult.__typename === 'LaunchRunSuccess') {
+      successfulRunIds.push(individualResult.run.id);
+
+      const pathname = `/runs/${individualResult.run.id}`;
+      const search = options.preserveQuerystring ? history.location.search : '';
+      const openInSameTab = () => history.push({pathname, search});
+
+      // using open with multiple runs will spam new tabs
+      if (options.behavior === 'open') {
+        openInSameTab();
+      } else {
+        // toast is more preferred
+        await showSharedToaster({
+          intent: 'success',
+          message: (
+            <div>
+              Launched run <Mono>{individualResult.run.id.slice(0, 8)}</Mono>
+            </div>
+          ),
+          action: {
+            text: 'View',
+            href: history.createHref({pathname, search}),
+          },
+        });
+      }
+      document.dispatchEvent(new CustomEvent('run-launched'));
+    } else if (individualResult.__typename === 'PythonError') {
+      showCustomAlert({
+        title: 'Error',
+        body: <PythonErrorInfo error={individualResult} />,
+      });
+    } else {
+      let message = `This multiple job launch cannot be executed.`;
+      if (
+        individualResult &&
+        typeof individualResult === 'object' &&
+        'errors' in individualResult
+      ) {
+        const errors = individualResult.errors as {message: string}[];
+        message += ` Please fix the following errors:\n\n${errors
+          .map((error) => error.message)
+          .join('\n\n')}`;
+      }
+      if (
+        individualResult &&
+        typeof individualResult === 'object' &&
+        'message' in individualResult
+      ) {
+        message += `\n\n${individualResult.message}`;
+      }
+
+      showCustomAlert({body: message});
+    }
+  }
+
+  // link to runs page filtered to run IDs
+  const params = new URLSearchParams();
+  successfulRunIds.forEach((id) => params.append('q[]', `id:${id}`));
+
+  const queryString = `/runs?${params.toString()}`;
+  history.push(queryString);
+}
+
 function getBaseExecutionMetadata(run: RunFragment | RunTableRunFragment) {
   const hiddenTagKeys: string[] = [DagsterTag.IsResumeRetry, DagsterTag.StepSelection];
 
@@ -204,6 +286,53 @@ export const LAUNCH_PIPELINE_EXECUTION_MUTATION = gql`
   ${PYTHON_ERROR_FRAGMENT}
 `;
 
+export const LAUNCH_MULTIPLE_RUNS_MUTATION = gql`
+  mutation LaunchMultipleRuns($executionParamsList: [ExecutionParams!]!) {
+    launchMultipleRuns(executionParamsList: $executionParamsList) {
+      __typename
+      launchMultipleRunsResult {
+        __typename
+        ... on LaunchRunSuccess {
+          run {
+            id
+            pipeline {
+              name
+            }
+            tags {
+              key
+              value
+            }
+            status
+            runConfigYaml
+            mode
+            resolvedOpSelection
+          }
+        }
+        ... on PipelineNotFoundError {
+          message
+        }
+        ... on InvalidSubsetError {
+          message
+        }
+        ... on RunConfigValidationInvalid {
+          errors {
+            message
+          }
+        }
+        ... on ConflictingExecutionParamsError {
+          message
+        }
+        ... on PresetNotFoundError {
+          preset
+          message
+        }
+        ...PythonErrorFragment
+      }
+    }
+  }
+  ${PYTHON_ERROR_FRAGMENT}
+`;
+
 export const DELETE_MUTATION = gql`
   mutation Delete($runId: String!) {
     deletePipelineRun(runId: $runId) {