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 } 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         if (process && process.container) {
  38             const logResources = await loadContainerLogs(process.container.uuid, logService);
  39             const initialState = createInitialLogPanelState(logResources);
  40             dispatch(processLogsPanelActions.INIT_PROCESS_LOGS_PANEL(initialState));
  41         }
  42     };
  43
  44 export const addProcessLogsPanelItem = (message: ResourceEventMessage<{ text: string }>) =>
  45     async (dispatch: Dispatch, getState: () => RootState, { logService }: ServiceRepository) => {
  46         if (PROCESS_PANEL_LOG_EVENT_TYPES.indexOf(message.eventType) > -1) {
  47             const uuid = getProcessLogsPanelCurrentUuid(getState().router);
  48             if (!uuid) { return }
  49             const process = getProcess(uuid)(getState().resources);
  50             if (!process) { return }
  51             const { containerRequest, container } = process;
  52             if (message.objectUuid === containerRequest.uuid
  53                 || (container && message.objectUuid === container.uuid)) {
  54                 dispatch(processLogsPanelActions.ADD_PROCESS_LOGS_PANEL_ITEM({
  55                     logType: ALL_FILTER_TYPE,
  56                     log: message.properties.text
  57                 }));
  58                 dispatch(processLogsPanelActions.ADD_PROCESS_LOGS_PANEL_ITEM({
  59                     logType: message.eventType,
  60                     log: message.properties.text
  61                 }));
  62                 if (MAIN_EVENT_TYPES.indexOf(message.eventType) > -1) {
  63                     dispatch(processLogsPanelActions.ADD_PROCESS_LOGS_PANEL_ITEM({
  64                         logType: MAIN_FILTER_TYPE,
  65                         log: message.properties.text
  66                     }));
  67                 }
  68             }
  69         }
  70     };
  71
  72 const loadContainerLogs = async (containerUuid: string, logService: LogService) => {
  73     const requestFilters = new FilterBuilder()
  74         .addEqual('object_uuid', containerUuid)
  75         .addIn('event_type', PROCESS_PANEL_LOG_EVENT_TYPES)
  76         .getFilters();
  77     const requestOrder = new OrderBuilder<LogResource>()
  78         .addAsc('eventAt')
  79         .getOrder();
  80     const requestParams = {
  81         limit: MAX_AMOUNT_OF_LOGS,
  82         filters: requestFilters,
  83         order: requestOrder,
  84     };
  85     const { items } = await logService.list(requestParams);
  86     return items;
  87 };
  88
  89 const createInitialLogPanelState = (logResources: LogResource[]) => {
  90     const allLogs = logsToLines(logResources);
  91     const mainLogs = logsToLines(logResources.filter(
  92         e => MAIN_EVENT_TYPES.indexOf(e.eventType) > -1
  93     ));
  94     const groupedLogResources = groupBy(logResources, log => log.eventType);
  95     const groupedLogs = Object
  96         .keys(groupedLogResources)
  97         .reduce((grouped, key) => ({
  98             ...grouped,
  99             [key]: logsToLines(groupedLogResources[key])
 100         }), {});
 101     const filters = [MAIN_FILTER_TYPE, ALL_FILTER_TYPE, ...Object.keys(groupedLogs)];
 102     const logs = {
 103         [MAIN_FILTER_TYPE]: mainLogs,
 104         [ALL_FILTER_TYPE]: allLogs,
 105         ...groupedLogs
 106     };
 107     return { filters, logs };
 108 };
 109
 110 const logsToLines = (logs: LogResource[]) =>
 111     logs.map(({ properties }) => properties.text);
 112
 113 export const navigateToLogCollection = (uuid: string) =>
 114     async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
 115         try {
 116             await services.collectionService.get(uuid);
 117             dispatch<any>(navigateTo(uuid));
 118         } catch {
 119             dispatch(snackbarActions.OPEN_SNACKBAR({ message: 'Could not request collection', hideDuration: 2000, kind: SnackbarKind.ERROR }));
 120         }
 121     };
 122
 123 const MAX_AMOUNT_OF_LOGS = 10000;
 124
 125 const ALL_FILTER_TYPE = 'All logs';
 126
 127 const MAIN_FILTER_TYPE = 'Main logs';
 128 const MAIN_EVENT_TYPES = [
 129     LogEventType.CRUNCH_RUN,
 130     LogEventType.STDERR,
 131     LogEventType.STDOUT,
 132 ];
 133
 134 const PROCESS_PANEL_LOG_EVENT_TYPES = [
 135     LogEventType.ARV_MOUNT,
 136     LogEventType.CRUNCH_RUN,
 137     LogEventType.CRUNCHSTAT,
 138     LogEventType.DISPATCH,
 139     LogEventType.HOSTSTAT,
 140     LogEventType.NODE_INFO,
 141     LogEventType.STDERR,
 142     LogEventType.STDOUT,
 143     LogEventType.CONTAINER,
 144     LogEventType.KEEPSTORE,
 145 ];