src/store/process-logs-panel/process-logs-panel-actions.ts

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 import { unionize, ofType, UnionOf } from "common/unionize";
   6 import { ProcessLogs, getProcessLogsPanelCurrentUuid } from './process-logs-panel';
   7 import { LogEventType } from 'models/log';
   8 import { RootState } from 'store/store';
   9 import { ServiceRepository } from 'services/services';
  10 import { Dispatch } from 'redux';
  11 import { groupBy, min, reverse } from 'lodash';
  12 import { LogResource } from 'models/log';
  13 import { LogService } from 'services/log-service/log-service';
  14 import { ResourceEventMessage } from 'websocket/resource-event-message';
  15 import { getProcess } from 'store/processes/process';
  16 import { FilterBuilder } from "services/api/filter-builder";
  17 import { OrderBuilder } from "services/api/order-builder";
  18 import { navigateTo } from 'store/navigation/navigation-action';
  19 import { snackbarActions, SnackbarKind } from 'store/snackbar/snackbar-actions';
  20
  21 export const processLogsPanelActions = unionize({
  22     RESET_PROCESS_LOGS_PANEL: ofType<{}>(),
  23     INIT_PROCESS_LOGS_PANEL: ofType<{ filters: string[], logs: ProcessLogs }>(),
  24     SET_PROCESS_LOGS_PANEL_FILTER: ofType<string>(),
  25     ADD_PROCESS_LOGS_PANEL_ITEM: ofType<{ logType: string, log: string }>(),
  26 });
  27
  28 export type ProcessLogsPanelAction = UnionOf<typeof processLogsPanelActions>;
  29
  30 export const setProcessLogsPanelFilter = (filter: string) =>
  31     processLogsPanelActions.SET_PROCESS_LOGS_PANEL_FILTER(filter);
  32
  33 export const initProcessLogsPanel = (processUuid: string) =>
  34     async (dispatch: Dispatch, getState: () => RootState, { logService }: ServiceRepository) => {
  35         dispatch(processLogsPanelActions.RESET_PROCESS_LOGS_PANEL());
  36         const process = getProcess(processUuid)(getState().resources);
  37         const maxPageSize = getState().auth.config.clusterConfig.API.MaxItemsPerResponse;
  38         if (process && process.container) {
  39             const logResources = await loadContainerLogs(process.container.uuid, logService, maxPageSize);
  40             const initialState = createInitialLogPanelState(logResources);
  41             dispatch(processLogsPanelActions.INIT_PROCESS_LOGS_PANEL(initialState));
  42         }
  43     };
  44
  45 export const addProcessLogsPanelItem = (message: ResourceEventMessage<{ text: string }>) =>
  46     async (dispatch: Dispatch, getState: () => RootState, { logService }: ServiceRepository) => {
  47         if (PROCESS_PANEL_LOG_EVENT_TYPES.indexOf(message.eventType) > -1) {
  48             const uuid = getProcessLogsPanelCurrentUuid(getState().router);
  49             if (!uuid) { return }
  50             const process = getProcess(uuid)(getState().resources);
  51             if (!process) { return }
  52             const { containerRequest, container } = process;
  53             if (message.objectUuid === containerRequest.uuid
  54                 || (container && message.objectUuid === container.uuid)) {
  55                 dispatch(processLogsPanelActions.ADD_PROCESS_LOGS_PANEL_ITEM({
  56                     logType: ALL_FILTER_TYPE,
  57                     log: message.properties.text
  58                 }));
  59                 dispatch(processLogsPanelActions.ADD_PROCESS_LOGS_PANEL_ITEM({
  60                     logType: message.eventType,
  61                     log: message.properties.text
  62                 }));
  63                 if (MAIN_EVENT_TYPES.indexOf(message.eventType) > -1) {
  64                     dispatch(processLogsPanelActions.ADD_PROCESS_LOGS_PANEL_ITEM({
  65                         logType: MAIN_FILTER_TYPE,
  66                         log: message.properties.text
  67                     }));
  68                 }
  69             }
  70         }
  71     };
  72
  73 const loadContainerLogs = async (containerUuid: string, logService: LogService, maxPageSize: number) => {
  74     const requestFilters = new FilterBuilder()
  75         .addEqual('object_uuid', containerUuid)
  76         .addIn('event_type', PROCESS_PANEL_LOG_EVENT_TYPES)
  77         .getFilters();
  78     const requestOrderAsc = new OrderBuilder<LogResource>()
  79         .addAsc('eventAt')
  80         .getOrder();
  81     const requestOrderDesc = new OrderBuilder<LogResource>()
  82         .addDesc('eventAt')
  83         .getOrder();
  84     const { items, itemsAvailable } = await logService.list({
  85         limit: maxPageSize,
  86         filters: requestFilters,
  87         order: requestOrderAsc,
  88     });
  89
  90     // Request additional logs if necessary
  91     const remainingLogs = itemsAvailable - items.length;
  92     if (remainingLogs > 0) {
  93         const { items: itemsLast } = await logService.list({
  94             limit: min([maxPageSize, remainingLogs]),
  95             filters: requestFilters,
  96             order: requestOrderDesc,
  97             count: 'none',
  98         })
  99         if (remainingLogs - itemsLast.length > 0) {
 100             const snipLine = {
 101                 ...items[items.length - 1],
 102                 eventType: LogEventType.SNIP,
 103                 properties: {
 104                     text: `================ 8< ================ 8< ========= Some log(s) were skipped ========= 8< ================ 8< ================`
 105                 },
 106             }
 107             return [...items, snipLine, ...reverse(itemsLast)];
 108         }
 109         return [...items, ...reverse(itemsLast)];
 110     }
 111     return items;
 112 };
 113
 114 const createInitialLogPanelState = (logResources: LogResource[]) => {
 115     const allLogs = logsToLines(logResources);
 116     const mainLogs = logsToLines(logResources.filter(
 117         e => MAIN_EVENT_TYPES.indexOf(e.eventType) > -1
 118     ));
 119     const groupedLogResources = groupBy(logResources, log => log.eventType);
 120     const groupedLogs = Object
 121         .keys(groupedLogResources)
 122         .reduce((grouped, key) => ({
 123             ...grouped,
 124             [key]: logsToLines(groupedLogResources[key])
 125         }), {});
 126     const filters = [
 127         MAIN_FILTER_TYPE,
 128         ALL_FILTER_TYPE,
 129         ...Object.keys(groupedLogs)
 130     ].filter(e => e !== LogEventType.SNIP);
 131     const logs = {
 132         [MAIN_FILTER_TYPE]: mainLogs,
 133         [ALL_FILTER_TYPE]: allLogs,
 134         ...groupedLogs
 135     };
 136     return { filters, logs };
 137 };
 138
 139 const logsToLines = (logs: LogResource[]) =>
 140     logs.map(({ properties }) => properties.text);
 141
 142 export const navigateToLogCollection = (uuid: string) =>
 143     async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
 144         try {
 145             await services.collectionService.get(uuid);
 146             dispatch<any>(navigateTo(uuid));
 147         } catch {
 148             dispatch(snackbarActions.OPEN_SNACKBAR({ message: 'Could not request collection', hideDuration: 2000, kind: SnackbarKind.ERROR }));
 149         }
 150     };
 151
 152 const ALL_FILTER_TYPE = 'All logs';
 153
 154 const MAIN_FILTER_TYPE = 'Main logs';
 155 const MAIN_EVENT_TYPES = [
 156     LogEventType.CRUNCH_RUN,
 157     LogEventType.STDERR,
 158     LogEventType.STDOUT,
 159     LogEventType.SNIP,
 160 ];
 161
 162 const PROCESS_PANEL_LOG_EVENT_TYPES = [
 163     LogEventType.ARV_MOUNT,
 164     LogEventType.CRUNCH_RUN,
 165     LogEventType.CRUNCHSTAT,
 166     LogEventType.DISPATCH,
 167     LogEventType.HOSTSTAT,
 168     LogEventType.NODE_INFO,
 169     LogEventType.STDERR,
 170     LogEventType.STDOUT,
 171     LogEventType.CONTAINER,
 172     LogEventType.KEEPSTORE,
 173     LogEventType.SNIP,
 174 ];