public static void serialize(SerializationStreamWriter streamWriter, ActionReturnValue instance) throws SerializationException { streamWriter.writeBoolean(instance.isValid()); streamWriter.writeObject(instance.getValidationMessages()); streamWriter.writeObject(instance.getExecuteFailedMessages()); streamWriter.writeBoolean(instance.getSucceeded()); streamWriter.writeBoolean(instance.getIsSynchronous()); streamWriter.writeString(instance.getDescription()); streamWriter.writeObject(instance.getTaskPlaceHolderIdList()); streamWriter.writeObject(instance.getVdsmTaskIdList()); streamWriter.writeBoolean(instance.getEndActionTryAgain()); streamWriter.writeObject(instance.getFault()); ObjectSerializer.serialize(streamWriter, instance.getActionReturnValue()); }
@Override protected void executeCallbacks(boolean success, ActionFlowState flowState, List<IFrontendActionAsyncCallback> callbacks) { Collections.shuffle(callbacks); for (IFrontendActionAsyncCallback callback : callbacks) { assertNotAllDone(flowState); ActionReturnValue result = new ActionReturnValue(); result.setValid(true); result.setSucceeded(success); callback.executed(new FrontendActionAsyncResult(ACTION_TYPE, null, result)); } }
/** * Translate application errors and store the translated messages back in return values. * @param errors A list of {@code ActionReturnValue}s. */ private void translateErrors(final Collection<ActionReturnValue> errors) { for (ActionReturnValue retVal : errors) { if (!retVal.isValid()) { retVal.setValidationMessages((ArrayList<String>) translateError(retVal)); } else if (!retVal.getSucceeded()) { EngineFault fault = retVal.getFault(); fault.setMessage(translateEngineFault(fault)); } } }
/** * Log the user out. * @param callback The callback to call when the operation is complete. */ @Override public void logout(final UserCallback callback) { //Remove the rpc token when logging out. xsrfRequestBuilder.setXsrfToken(null); ActionReturnValue retVal = new ActionReturnValue(); retVal.setSucceeded(true); callback.onSuccess(retVal); } }
boolean failedOnValidate = !result.isValid(); if (failedOnValidate) { result.setValidationMessages((ArrayList<String>) translateError(result)); } else if (!result.getSucceeded()) { EngineFault fault = result.getFault(); String message = result.getExecuteFailedMessages().size() > 1 ? translateExecuteFailedMessages(result.getExecuteFailedMessages()) : translateEngineFault(fault); fault.setMessage(message); if (showErrorDialog && result.getIsSynchronous() && getEventsHandler() != null) { getEventsHandler().runActionExecutionFailed(actionType, fault); && getEventsHandler().isRaiseErrorModalPanel(actionType, result.getFault())) { ArrayList<String> messages = result.getValidationMessages(); failureEventHandler(result.getDescription(),
public static void deserialize(SerializationStreamReader streamReader, ActionReturnValue instance) throws SerializationException { instance.setValid(streamReader.readBoolean()); instance.setValidationMessages((ArrayList<String>) streamReader.readObject()); instance.setExecuteFailedMessages((ArrayList<String>) streamReader.readObject()); instance.setSucceeded(streamReader.readBoolean()); instance.setIsSynchronous(streamReader.readBoolean()); instance.setDescription(streamReader.readString()); instance.setTaskPlaceHolderIdList((ArrayList<Guid>) streamReader.readObject()); instance.setVdsmTaskIdList((ArrayList<Guid>) streamReader.readObject()); instance.setEndActionTryAgain(streamReader.readBoolean()); instance.setFault((EngineFault) streamReader.readObject()); instance.setActionReturnValue(ObjectSerializer.deserialize(streamReader)); }
private void prepare3() { PreparingEnlistment enlistment = (PreparingEnlistment) context.enlistment; EnlistmentContext enlistmentContext = (EnlistmentContext) enlistment.getContext(); ActionReturnValue returnValue = context.addDataCenterReturnValue; context.enlistment = null; if (returnValue != null && returnValue.getSucceeded()) { enlistmentContext.setDataCenterId((Guid) returnValue.getActionReturnValue()); enlistment.prepared(); } else { enlistment.forceRollback(); } }
when(mockValidateErrorsTranslator.translateErrorText(any())).thenReturn(translatedErrors); ActionParametersBase testParameters = new ActionParametersBase(); ActionReturnValue returnValue = new ActionReturnValue(); returnValue.setFault(testFault); returnValue.setDescription("This is a description"); //$NON-NLS-1$ returnValue.getValidationMessages().add("Message 1"); //$NON-NLS-1$ returnValue.getValidationMessages().add("Message 2"); //$NON-NLS-1$ returnValue.setValid(false); // Yes this is the default, but to make sure. frontend.handleActionResult(ActionType.AddDisk, testParameters, returnValue, mockActionCallback, testState, true);
Object[] queryValues, Object queryReturn) { ActionReturnValue taskResult = new ActionReturnValue(); taskResult.setValid(valid); if (valid) { taskResult.setSucceeded(success); if (success) { taskResult.setActionReturnValue(taskReturn); } else { taskResult.setExecuteFailedMessages(asList(FAILURE)); setUpL10nExpectations(asList(FAILURE)); taskResult.setValidationMessages(asList(CANT_DO)); setUpL10nExpectations(asList(CANT_DO)); taskResult.setVdsmTaskIdList(asyncTasks); QueryReturnValue monitorResult = new QueryReturnValue(); monitorResult.setSucceeded(success);
private void setErrorMessage(ActionReturnValue result, GlusterVolumeGeoRepActionConfirmationModel cModel) { String errorMessage = ""; //$NON-NLS-1$ if (result == null) { errorMessage = ConstantsManager.getInstance().getConstants().testFailedUnknownErrorMsg(); } else if (!result.getSucceeded()) { errorMessage = result.isValid() ? result.getFault().getMessage() : result.getValidationMessages().get(0); } cModel.setActionConfirmationMessage(errorMessage); } }
protected ActionReturnValue doAction(ActionType task, ActionParametersBase params) throws BackendFailureException { BackendLocal backend = getBackend(); setJobOrStepId(params); setCorrelationId(params); ActionReturnValue result = backend.runAction(task, sessionize(params)); if (result != null && !result.isValid()) { backendFailure(result.getValidationMessages()); } else if (result != null && !result.getSucceeded()) { backendFailure(result.getExecuteFailedMessages()); } assert result != null; return result; }
public void runMultipleActionsFailed(List<ActionType> actions, List<ActionReturnValue> returnValues, MessageFormatter messageFormatter) { List<Message> errors = new ArrayList<>(); int actionNum = 0; for (ActionReturnValue v : returnValues) { if (isRaiseErrorModalPanel(actions.get(actionNum++), v.getFault())) { String description = (v.getDescription() != null && !"".equals(v.getDescription().trim())) || returnValues.size() == 1 ? v.getDescription() : ConstantsManager.getInstance().getConstants().action() + " " + actionNum; //$NON-NLS-1$ //$NON-NLS-2$ if (!v.isValid()) { for (String validateMessage : v.getValidationMessages()) { errors.add(new Message(description, validateMessage)); } } else { errors.add(new Message(description, v.getFault().getMessage())); } } } errorPopupManager.show(messageFormatter.format(ErrorMessageFormatter.formatMessages(errors))); }
private void initiateResumeUploadStartTransfer(FrontendActionAsyncResult result) { if (result.getReturnValue() != null && result.getReturnValue().getSucceeded()) { ImageTransfer rv = result.getReturnValue().getActionReturnValue(); setCommandId(rv.getId()); setBytesSent(rv.getBytesSent()); setBytesEndOffset(rv.getBytesTotal()); startStatusPolling(); } else { setProgressStr(messages.uploadImageFailedToResumeMessage(result.getReturnValue().getDescription())); } }
public void postSnapshotAction(ActionReturnValue returnValue) { if (returnValue != null && returnValue.getSucceeded()) { setWindow(null); } }
public static ActionReturnValue instantiate(SerializationStreamReader streamReader) throws SerializationException { return new ActionReturnValue(); }
public void testHandleActionResult_SucceededFalse() { ActionParametersBase testParameters = new ActionParametersBase(); ActionReturnValue returnValue = new ActionReturnValue(); returnValue.setValid(true); returnValue.setIsSynchronous(true); returnValue.setSucceeded(false); // Yes this is the default, but to make sure. EngineFault testFault = new EngineFault(); returnValue.setFault(testFault); frontend.handleActionResult(ActionType.AddDisk, testParameters, returnValue, mockActionCallback, testState, true);
eq(false), callbackMultipleActions.capture()); ArrayList<ActionReturnValue> returnValues = new ArrayList<>(); returnValues.add(new ActionReturnValue()); returnValues.add(new ActionReturnValue()); returnValues.get(0).setValid(true); returnValues.get(1).setValid(true); callbackMultipleActions.getValue().onSuccess(returnValues); verify(mockFrontendFailureEvent, never()).raise(eq(Frontend.class), (FrontendFailureEventArgs) any());
private IFrontendMultipleActionAsyncCallback createCallback() { return result -> { boolean hasError = false; for (ActionReturnValue singleResult : result.getReturnValue()) { if (!singleResult.isValid() || (waitForResult && !singleResult.getSucceeded())) { hasError = true; getActionFlowState().addFailure(actionType, singleResult); } } if (hasError && !runNextInCaseOfError) { then(null); } runNextAction(); }; }
result -> { final ActionReturnValue logonCommandReturnValue = result.getReturnValue(); boolean isLogonSucceeded = logonCommandReturnValue != null && logonCommandReturnValue.getSucceeded(); if (isLogonSucceeded) { invokeClient(); } else { if (logonCommandReturnValue != null && logonCommandReturnValue.getFault().getError() == EngineError.nonresp) { UICommand okCommand = new UICommand("SpiceWithoutAgentOK", new BaseCommandTarget() { //$NON-NLS-1$ } else { logSsoOnDesktopFailed(getLogger(), logonCommandReturnValue != null ? logonCommandReturnValue.getDescription() : ""); //$NON-NLS-1$
@Override public void onSuccess(final List<VdcOperation<ActionType, ActionParametersBase>> operationList, final List<ActionReturnValue> resultObject) { logger.finer("Frontend: successfully executed runMultipleAction, determining result!"); //$NON-NLS-1$ List<ActionReturnValue> failed = resultObject.stream() .filter(v -> !v.isValid()) .collect(Collectors.toList()); if (showErrorDialog && !failed.isEmpty()) { translateErrors(failed); getEventsHandler().runMultipleActionFailed(actionType, failed); } if (callback != null) { callback.executed(new FrontendMultipleActionAsyncResult(actionType, parameters, resultObject, state)); } fireAsyncActionSucceededEvent(state); }