| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| import {HIDE_INTERSTITIAL_SPINNER_EVENT} from 'brooklyn-ui-utils/interstitial-spinner/interstitial-spinner'; |
| import template from "./detail.template.html"; |
| import modalTemplate from './kilt.modal.template.html'; |
| import {makeTaskStubFromWorkflowRecord} from "../activities.controller"; |
| import jsyaml from 'js-yaml'; |
| import runWorkflowModalTemplate from "../../run-workflow-modal.template.html"; |
| import {runWorkflowController} from "../../inspect.controller"; |
| |
| export const detailState = { |
| name: 'main.inspect.activities.detail', |
| url: '/:activityId?workflowId?workflowLatestRun', |
| template: template, |
| controller: ['$scope', '$state', '$stateParams', '$location', '$log', '$uibModal', '$timeout', '$sanitize', '$sce', 'activityApi', 'entityApi', 'brUtilsGeneral', DetailController], |
| controllerAs: 'vm', |
| } |
| function DetailController($scope, $state, $stateParams, $location, $log, $uibModal, $timeout, $sanitize, $sce, activityApi, entityApi, Utils) { |
| $scope.$emit(HIDE_INTERSTITIAL_SPINNER_EVENT); |
| |
| const { |
| applicationId, |
| entityId, |
| activityId, |
| } = $stateParams; |
| $scope.workflowId = $stateParams.workflowId; |
| |
| let vm = this; |
| vm.redirectToWorkflowLatestRun = $stateParams.workflowLatestRun; |
| $stateParams.workflowLatestRun = null; |
| $location.search('workflowLatestRun', null) |
| |
| vm.model = { |
| appId: applicationId, |
| entityId: entityId, |
| activityId: activityId, |
| childFilter: {'EFFECTOR': true, 'SUB-TASK': false}, |
| accordion: {summaryOpen: true, subTaskOpen: true, streamsOpen: true, workflowOpen: true}, |
| activity: {}, |
| workflow: {}, |
| }; |
| |
| vm.modalTemplate = modalTemplate; |
| vm.wideKilt = false; |
| vm.toggleOldWorkflowRunStepDetails = () => { $scope.showOldWorkflowRunStepDetails = !$scope.showOldWorkflowRunStepDetails; } |
| |
| $scope.actions = {}; |
| |
| let observers = []; |
| |
| if ($state.current.name === detailState.name) { |
| |
| function onActivityOrWorkflowUpdate() { |
| delete $scope.actions['cancel']; |
| delete $scope.actions['delete']; |
| |
| if (!vm.model.activity.endTimeUtc || vm.model.activity.endTimeUtc<=0) { |
| $scope.actions.cancel = { label: 'Cancel task', doAction: () => { activityApi.cancelActivity(activityId); } }; |
| } else if (vm.model.workflow.data && vm.model.workflow.data.taskId && vm.model.workflow.data.status === 'RUNNING') { |
| $scope.actions.cancel = { label: 'Cancel workflow', doAction: () => { activityApi.cancelActivity(vm.model.workflow.taskId); } }; |
| } else if (vm.model.workflow.data && vm.model.workflow.tag) { |
| $scope.actions.delete = { label: 'Delete workflow', doAction: () => { |
| entityApi.deleteWorkflow(vm.model.workflow.tag.applicationId || applicationId, vm.model.workflow.tag.entityId || entityId, $scope.workflowId) |
| .then(result => $state.go($state.current, {}, {reload: true}) ); |
| } }; |
| } |
| |
| if (vm.model.activity.result!=undefined) { |
| vm.model.activity.resultYaml = vm.yaml(vm.model.activity.result); |
| const lines = vm.model.activity.resultYaml.split('\n'); |
| vm.model.activity.resultLineCount = lines.length; |
| vm.model.activity.resultLineMaxLen = Math.max(...lines.map(x => x.length)); |
| } |
| } |
| |
| function loadWorkflow(workflowTag, opts) { |
| if (!opts) opts = {}; |
| if (!workflowTag) { |
| workflowTag = {} |
| opts.optimistic = true; |
| } |
| const optimistic = opts.optimistic; |
| |
| vm.model.workflow.loading = 'loading'; |
| |
| $scope.workflowId = workflowTag.workflowId || $scope.workflowId || activityId; |
| return entityApi.getWorkflow(workflowTag.applicationId || applicationId, workflowTag.entityId || entityId, $scope.workflowId).then(wResponse => { |
| $scope.workflowId = wResponse.data.workflowId; |
| workflowTag = {applicationId, entityId, workflowId: $scope.workflowId, ...workflowTag}; |
| if (optimistic) { |
| vm.model.workflow.tag = workflowTag; |
| } |
| vm.model.workflow.data = wResponse.data; |
| vm.model.workflow.loading = 'loaded'; |
| vm.model.workflow.applicationId = workflowTag.applicationId; |
| vm.model.workflow.entityId = workflowTag.entityId; |
| |
| if (opts.nonTask) { |
| const wft = (vm.model.workflow.data.replays || []).find(t => t.taskId === activityId); |
| if (wft) { |
| vm.model.activity = makeTaskStubFromWorkflowRecord(vm.model.workflow.data, wft); |
| vm.model.workflow.tag = getTaskWorkflowTag(vm.model.activity); |
| } else { |
| throw "Workflow task " + activityId + " not stored on workflow"; |
| } |
| |
| // give a better error |
| vm.error = $sce.trustAsHtml('Limited information on workflow task <b>' + _.escape(activityId) + '</b>.<br/><br/>' + |
| (!vm.model.activity.endTimeUtc || vm.model.activity.endTimeUtc == -1 |
| ? "The run appears to have been interrupted, either by a server restart or a failure or cancellation and removal from memory." |
| : 'The workflow is known but this task is no longer stored in memory.')); |
| } |
| |
| function processWorkflowData(wResponse2) { |
| // change the workflow object so widgets get refreshed |
| vm.model.workflow = { ...vm.model.workflow, data: wResponse2.data }; |
| |
| vm.model.workflow.isError = !!(vm.model.workflow.data.status && vm.model.workflow.data.status.startsWith("ERROR")); |
| |
| const replays = (vm.model.workflow.data.replays || []); |
| |
| vm.model.workflow.runMultipleTimes = replays.length > 1; |
| let workflowReplayId = activityId; |
| if (!replays.find(r => r.taskId === workflowReplayId)) { |
| let submittedById = ((vm.model.activity.submittedByTask || {}).metadata || {}).id; |
| if (replays.find(r => r.taskId === submittedById)) workflowReplayId = submittedById; |
| else workflowReplayId = null; |
| } |
| if (workflowReplayId) { |
| vm.model.workflow.runReplayId = workflowReplayId; |
| vm.model.workflow.runIsLatest = workflowReplayId == (replays[replays.length - 1] || {}).taskId; |
| vm.model.workflow.runIsOld = !vm.model.workflow.runIsLatest; |
| } |
| if (vm.model.workflow.runIsOld && vm.redirectToWorkflowLatestRun) { |
| vm.redirectToWorkflowLatestRun = false; |
| $state.go('main.inspect.activities.detail', { |
| applicationId: applicationId, |
| entityId: entityId, |
| activityId: (replays[replays.length - 1] || {}).taskId, |
| }); |
| } |
| |
| let osi = vm.model.workflow.data.oldStepInfo; |
| vm.model.workflow.finishedWithNoSteps = ((osi["-2"] || {}).previous || [])[0] == -1; |
| |
| $scope.actions.workflowReplays = []; |
| if (vm.model.workflow.data.status !== 'RUNNING') { |
| |
| $scope.actions.workflowReplays = []; |
| const stepIndex = (vm.model.workflow.tag || {}).stepIndex; // selected by user |
| const currentStepIndex = vm.model.workflow.data.currentStepIndex; // of workflow |
| |
| let replayableDisabled = vm.model.workflow.data.replayableDisabled; |
| let replayableFromStart = vm.model.workflow.data.replayableFromStart && !replayableDisabled, |
| replayableFromLastStep = vm.model.workflow.data.replayableLastStep>=0 && !replayableDisabled; |
| |
| if (replayableFromLastStep) { |
| let msg = 'Replay from last replay point (step '+(vm.model.workflow.data.replayableLastStep+1)+')'; |
| $scope.actions.workflowReplays.push({ targetId: 'last', reason: msg+' from UI', label: msg }); |
| } |
| |
| // get current step, replay from that step |
| if (stepIndex>=0) { |
| const osi = vm.model.workflow.data.oldStepInfo[stepIndex] || {}; |
| if (osi.replayableFromHere && !replayableDisabled) { |
| $scope.actions.workflowReplays.push({ targetId: ''+stepIndex, reason: 'Replay from step '+(stepIndex+1)+' from UI', |
| label: 'Replay from here (step '+(stepIndex+1)+')' }); |
| } else { |
| $scope.actions.workflowReplays.push({ targetId: ''+stepIndex, reason: 'Force replay from step '+(stepIndex+1)+' from UI', |
| label: 'Force replay from here (step '+(stepIndex+1)+')', force: true }); |
| } |
| } |
| |
| if (replayableFromStart) { |
| let w1 = 'Replay from start', w2 = '(no other replay points)'; |
| if (stepIndex<0 || (_.isNil(stepIndex) && vm.model.workflow.data.replayableLastStep==-2)) { w1 = 'Run'; w2 = 'again'; } |
| else if (replayableFromLastStep) w2 = ''; |
| else if (_.isNil(stepIndex)) { w2 = '(did not start)'; } |
| |
| $scope.actions.workflowReplays.push({targetId: 'start', reason: 'Replay from start from UI', |
| label: w1+' '+w2}); |
| } |
| |
| if (currentStepIndex>=0 && currentStepIndex < vm.model.workflow.data.stepsDefinition.length) { |
| let msg = 'eplay resuming (at step ' + (currentStepIndex + 1); |
| if (!replayableDisabled) { |
| $scope.actions.workflowReplays.push({ targetId: 'last', label: 'R'+msg+' if possible)', reason: 'R'+msg+') from UI' }); |
| } |
| $scope.actions.workflowReplays.push({ targetId: 'last', label: 'Force r'+msg+')', reason: 'Force r'+msg+') from UI', force: true }); |
| } |
| |
| if (!replayableFromStart) { |
| $scope.actions.workflowReplays.push({targetId: 'start', reason: 'Force replay from start from UI', |
| label: 'Force replay from start', force: true}); |
| } |
| |
| // force replays |
| $scope.actions.workflowReplays.forEach(r => { |
| // could prompt for a reason |
| r.action = () => { |
| const opts = {}; |
| opts.reason = r.reason; |
| if (r.force) opts.force = true; |
| entityApi.replayWorkflow(applicationId, entityId, $scope.workflowId, r.targetId, opts) |
| .then(response => { |
| console.log("Replay requested", response); |
| $state.go('main.inspect.activities.detail', { |
| applicationId: applicationId, |
| entityId: entityId, |
| activityId: response.data.id, |
| }); |
| }).catch(error => { |
| console.log("Replay failed", error); |
| }); |
| }; |
| }); |
| } |
| if (!$scope.actions.workflowReplays.length) delete $scope.actions['workflowReplays']; |
| |
| onActivityOrWorkflowUpdate(); |
| } |
| |
| processWorkflowData(wResponse); |
| |
| if (vm.model.workflow.data.status === 'RUNNING') wResponse.interval(1000); |
| observers.push(wResponse.subscribe(processWorkflowData, error => { |
| console.debug("Workflow no longer available, likely completed with retention 0. Removing from view.", error); |
| vm.model.workflow = {}; |
| })); |
| |
| function initFromWorkflowFirstReplayTask(task) { |
| if (task) { |
| const workflowYaml = (task.tags || []).find(t => t.workflow_yaml); |
| if (workflowYaml) { |
| $scope.workflow_yaml = workflowYaml.workflow_yaml; |
| } |
| } |
| } |
| |
| if ($scope.workflowId === activityId) initFromWorkflowFirstReplayTask(vm.model.activity); |
| else activityApi.activity($scope.workflowId).then((response)=> { |
| initFromWorkflowFirstReplayTask(response.data); |
| }); |
| |
| |
| }).catch(error => { |
| if (optimistic) { |
| vm.model.workflow.loading = null; |
| throw error; |
| } |
| console.log("Unable to load workflow", $scope.workflowId, error); |
| |
| vm.model.workflow.loading = 'error'; |
| }); |
| }; |
| |
| activityApi.activity(activityId).then((response)=> { |
| vm.model.activity = response.data; |
| |
| initializeBreadcrumbs(response.data); |
| |
| delete $scope.actions['effector']; |
| delete $scope.actions['invokeAgain']; |
| if ((vm.model.activity.tags || []).find(t => t=="EFFECTOR")) { |
| const effectorName = (vm.model.activity.tags.find(t => t.effectorName) || {}).effectorName; |
| const effectorParams = (vm.model.activity.tags.find(t => t.effectorParams) || {}).effectorParams; |
| if (effectorName) { |
| $scope.actions.effector = {effectorName}; |
| if (effectorParams) { |
| $scope.actions.invokeAgain = {effectorName, effectorParams, doAction: () => vm.invokeEffector(effectorName, effectorParams) }; |
| } |
| } |
| } |
| |
| $scope.workflowId = null; // if the task loads, force the workflow id to be found on it, otherwise ignore it |
| if ((vm.model.activity.tags || []).find(t => t=="WORKFLOW")) { |
| const workflowTag = getTaskWorkflowTag(vm.model.activity); |
| if (workflowTag) { |
| vm.model.workflow.tag = workflowTag; |
| loadWorkflow(workflowTag); |
| } |
| const workflowYaml = vm.model.activity.tags.find(t => t.workflow_yaml); |
| if (workflowYaml) { |
| $scope.workflow_yaml = workflowYaml.workflow_yaml; |
| } |
| } |
| |
| function saveActivity(response) { |
| vm.model.activity = response.data; |
| onActivityOrWorkflowUpdate(); |
| vm.error = undefined; |
| vm.errorBasic = false; |
| } |
| |
| saveActivity(response); |
| |
| if (!vm.model.activity.endTimeUtc || vm.model.activity.endTimeUtc<0) response.interval(1000); |
| observers.push(response.subscribe(saveActivity)); |
| |
| }).catch((error)=> { |
| $log.warn('Error loading activity for '+activityId, error); |
| // prefer this simpler error message over the specific ones below |
| vm.errorBasic = true; |
| vm.error = $sce.trustAsHtml('Cannot load task with ID: <b>' + _.escape(activityId) + '</b> <br/><br/>' + |
| 'The task is no longer stored in memory. Details may be available in logs.'); |
| |
| // in case it corresponds to a workflow and not a task, try loading as a workflow |
| loadWorkflow({workflowId: activityId}, { nonTask: true }) |
| .catch(error => { |
| loadWorkflow(null, { nonTask: true }) |
| .catch(error => { |
| $log.debug("ID "+activityId+"/"+$scope.workflowId+" does not correspond to workflow either", error); |
| }); |
| }); |
| }); |
| |
| function onActivityLoadUpdate() { |
| vm.model.activityChildrenAndDeep = []; |
| let seen = {}; |
| if (vm.model.activityChildren) { |
| vm.model.activityChildren.forEach(t => { |
| vm.model.activityChildrenAndDeep.push(t); |
| seen[t.id] = true; |
| }); |
| } |
| if (vm.model.activitiesDeep) { |
| Object.values(vm.model.activitiesDeep).forEach(t => { |
| if (!seen[t.id]) { |
| vm.model.activityChildrenAndDeep.push(t); |
| seen[t.id] = true; |
| } |
| }); |
| } |
| } |
| |
| $scope.breadcrumbsLoading = true; |
| $scope.breadcrumbs = []; |
| $scope.breadcrumbsExpanded = false; |
| function initializeBreadcrumbs(activity) { |
| $scope.breadcrumbs.unshift(activity); |
| if (activity.submittedByTask) { |
| activityApi.activity(activity.submittedByTask.metadata.id).then(response => { |
| initializeBreadcrumbs(response.data); |
| }).catch(e => { |
| console.warn("Error loading breadcrumbs", e); |
| $scope.breadcrumbsLoading = false; |
| }); |
| } else { |
| $scope.breadcrumbsLoading = false; |
| } |
| } |
| vm.expandBreadcrumbs = () => { |
| $scope.breadcrumbsExpanded = true; |
| } |
| |
| activityApi.activityChildren(activityId).then((response)=> { |
| vm.model.activityChildren = processActivityChildren(response.data); |
| vm.error = undefined; |
| onActivityLoadUpdate(); |
| |
| // could improve by making just one call for children+deep, or combining the results; |
| // but for now just read them both frequently |
| if (!vm.model.activity.endTimeUtc || vm.model.activity.endTimeUtc<0) response.interval(1000); |
| observers.push(response.subscribe((response)=> { |
| vm.model.activityChildren = processActivityChildren(response.data); |
| if (!vm.errorBasic) { |
| vm.error = undefined; |
| } |
| onActivityLoadUpdate(); |
| })); |
| }).catch((error)=> { |
| $log.warn('Error loading activity children for '+activityId, error); |
| if (!vm.errorBasic) { |
| vm.error = 'Cannot load activity children for activity ID: ' + activityId; |
| } |
| }); |
| |
| activityApi.activityDescendants(activityId, 8, true).then((response)=> { |
| vm.model.activitiesDeep = response.data; |
| vm.error = undefined; |
| onActivityLoadUpdate(); |
| |
| if (!vm.model.activity.endTimeUtc || vm.model.activity.endTimeUtc<0) response.interval(1000); |
| observers.push(response.subscribe((response)=> { |
| vm.model.activitiesDeep = response.data; |
| if (!vm.errorBasic) { |
| vm.error = undefined; |
| } |
| onActivityLoadUpdate(); |
| })); |
| }).catch((error)=> { |
| $log.warn('Error loading activity children deep for '+activityId, error); |
| if (!vm.errorBasic) { |
| vm.error = 'Cannot load activities children deep for activity ID: ' + activityId; |
| } |
| }); |
| |
| } |
| |
| vm.isNonEmpty = Utils.isNonEmpty; |
| vm.yaml = (o) => typeof o === 'string' ? o : jsyaml.dump(o); |
| |
| vm.openInRunModel = function (workflowYaml) { |
| $uibModal.open({ |
| animation: true, |
| template: runWorkflowModalTemplate, |
| controller: ['$scope', '$http', '$uibModalInstance', 'serverApi', 'applicationId', 'entityId', 'workflowYaml', runWorkflowController], |
| size: 'lg', |
| resolve: { |
| applicationId: ()=>(applicationId), |
| entityId: ()=>(entityId), |
| workflowYaml: ()=>(workflowYaml), |
| } |
| }).result.then((closeData)=> { |
| $state.go('main.inspect.activities.detail', { |
| applicationId: applicationId, |
| entityId: closeData.entityId, |
| activityId: closeData.id |
| }); |
| }); |
| } |
| |
| vm.getStreamIdsInOrder = function () { |
| // sort with known streams first, in preferred order |
| // also return just the IDs, setting a map |
| var knownMap = {env: null, stdin: null, stdout: null, stderr: null}; |
| var otherMap = {}; |
| for (let [name, s] of Object.entries(vm.model.activity.streams)) { |
| if (name in knownMap) { |
| knownMap[name] = s; |
| } else { |
| otherMap[name] = s; |
| } |
| } |
| |
| // Do not display streams that are not initialized |
| for (let name in knownMap) { |
| if (knownMap[name] === null || knownMap[name] === undefined) { |
| delete knownMap[name]; |
| } |
| } |
| |
| $scope.streamsById = Object.assign({}, knownMap, otherMap); |
| return Object.keys($scope.streamsById); |
| }; |
| |
| vm.setWideKilt = function (newValue) { |
| vm.wideKilt = newValue; |
| // empirically delay of 100ms means it runs after the resize; |
| // seems there is no way to hook in to resize events so it is |
| // either this or a $scope.$watch with very low interval |
| $timeout(function() { $scope.$broadcast('resize') }, 100); |
| }; |
| |
| vm.stringify = (data) => JSON.stringify(data, null, 2); |
| vm.stringifiedSize = (data) => JSON.stringify(data).length; |
| |
| vm.invokeEffector = (effectorName, effectorParams) => { |
| entityApi.invokeEntityEffector(applicationId, entityId, effectorName, effectorParams).then((response) => { |
| $state.go('main.inspect.activities.detail', { |
| applicationId: applicationId, |
| entityId: entityId, |
| activityId: response.data.id, |
| }); |
| }); |
| } |
| |
| $scope.$on('$destroy', ()=> { |
| observers.forEach((observer)=> { |
| observer.unsubscribe(); |
| }); |
| }); |
| |
| function processActivityChildren(data) { |
| return data.map((child)=> { |
| if (child.submittedByTask && child.submittedByTask.metadata.id === activityId && child.tags.indexOf('SUB-TASK') === -1) { |
| child.tags.push("BACKGROUND-TASK"); |
| } |
| return child; |
| }); |
| } |
| |
| vm.onFilteredActivitiesChange = function (newActivities, globalFilters) { |
| // this uses activity descendants api method which only uses TaskChildren, |
| // so transient tasks etc less relevant |
| } |
| |
| vm.showReplayHelp = () => { |
| $scope.showReplayHelp = !$scope.showReplayHelp; |
| } |
| |
| vm.isNullish = _.isNil; |
| vm.isEmpty = x => vm.isNullish(x) || (x.length==0) || (typeof x === 'object' && !Object.keys(x).length); |
| vm.isNonEmpty = x => !vm.isEmpty(x); |
| } |
| |
| export function getTaskWorkflowTag(task) { |
| if (!task) return null; |
| if (!task.tags) return null; |
| return task.tags.find(t => t.workflowId); |
| } |
