@Override protected void runInContext() { this.callback.complete(this.answer); } }
@Override public void complete(Object resultObject) { _resultObject = resultObject; _driver.performCompletionCallback(this); }
@Override public void performCompletionCallback(AsyncCallbackDispatcher callback) { AsyncCallbackDispatcher.dispatch(callback.getTargetObject(), callback); } }
private AsyncCallFuture<TemplateApiResult> copyAsync(DataObject source, TemplateInfo template, DataStore store) { AsyncCallFuture<TemplateApiResult> future = new AsyncCallFuture<TemplateApiResult>(); DataObject templateOnStore = store.create(template); templateOnStore.processEvent(Event.CreateOnlyRequested); TemplateOpContext<TemplateApiResult> context = new TemplateOpContext<TemplateApiResult>(null, (TemplateObject)templateOnStore, future); AsyncCallbackDispatcher<TemplateServiceImpl, CopyCommandResult> caller = AsyncCallbackDispatcher.create(this); caller.setCallback(caller.getTarget().copyTemplateCallBack(null, null)).setContext(context); _motionSrv.copyAsync(source, templateOnStore, caller); return future; }
protected Void revertSnapshotCallback(AsyncCallbackDispatcher<SnapshotServiceImpl, CommandResult> callback, RevertSnapshotContext<CommandResult> context) { CommandResult result = callback.getResult(); AsyncCallFuture<SnapshotResult> future = context.future; SnapshotResult res = null; try { if (result.isFailed()) { s_logger.debug("revert snapshot failed" + result.getResult()); res = new SnapshotResult(context.snapshot, null); res.setResult(result.getResult()); } else { res = new SnapshotResult(context.snapshot, null); } } catch (Exception e) { s_logger.debug("Failed to in revertSnapshotCallback", e); res.setResult(e.toString()); } future.complete(res); return null; }
public Void deleteCallback(AsyncCallbackDispatcher<SamplePrimaryDataStoreDriverImpl, Answer> callback, AsyncRpcContext<CommandResult> context) { CommandResult result = new CommandResult(); Answer answer = callback.getResult(); if (!answer.getResult()) { result.setResult(answer.getDetails()); } context.getParentCallback().complete(result); return null; }
/** * We will check if the given volume is in the primary storage. If it is, we will execute an asynchronous call to delete it there. * If the volume is not in the primary storage, we do nothing here. */ protected void expungeVolumesInPrimaryStorageIfNeeded(VolumeVO volume) throws InterruptedException, ExecutionException { VolumeInfo volOnPrimary = volFactory.getVolume(volume.getId(), DataStoreRole.Primary); if (volOnPrimary != null) { s_logger.info("Expunging volume " + volume.getId() + " from primary data store"); AsyncCallFuture<VolumeApiResult> future = volService.expungeVolumeAsync(volOnPrimary); future.get(); } }
public static boolean dispatch(Object target, AsyncCallbackDispatcher callback) { assert (callback != null); assert (target != null); try { callback.getCallbackMethod().invoke(target, callback, callback.getContext()); } catch (IllegalArgumentException e) { throw new RuntimeException("IllegalArgumentException when invoking RPC callback for command: " + callback.getCallbackMethod().getName()); } catch (IllegalAccessException e) { throw new RuntimeException("IllegalAccessException when invoking RPC callback for command: " + callback.getCallbackMethod().getName()); } catch (InvocationTargetException e) { throw new RuntimeException("InvocationTargetException when invoking RPC callback for command: " + callback.getCallbackMethod().getName(), e); } return true; } }
public static <P, R> AsyncCallbackDispatcher<P, R> create(P target) { return new AsyncCallbackDispatcher<P, R>(target); }
@Override public AsyncCallFuture<TemplateApiResult> deleteTemplateAsync(TemplateInfo template) { TemplateObject to = (TemplateObject)template; // update template_store_ref status to.processEvent(ObjectInDataStoreStateMachine.Event.DestroyRequested); AsyncCallFuture<TemplateApiResult> future = new AsyncCallFuture<TemplateApiResult>(); TemplateOpContext<TemplateApiResult> context = new TemplateOpContext<TemplateApiResult>(null, to, future); AsyncCallbackDispatcher<TemplateServiceImpl, CommandResult> caller = AsyncCallbackDispatcher.create(this); caller.setCallback(caller.getTarget().deleteTemplateCallback(null, null)).setContext(context); to.getDataStore().getDriver().deleteAsync(to.getDataStore(), to, caller); return future; }
public void callback(DownloadAnswer answer) { if (_callback != null) { _callback.complete(answer); } }
public Void deleteTemplateCallback(AsyncCallbackDispatcher<TemplateServiceImpl, CommandResult> callback, TemplateOpContext<TemplateApiResult> context) { CommandResult result = callback.getResult(); TemplateObject vo = context.getTemplate(); if (result.isSuccess()) { vo.processEvent(Event.OperationSuccessed); } else { vo.processEvent(Event.OperationFailed); } TemplateApiResult apiResult = new TemplateApiResult(vo); apiResult.setResult(result.getResult()); apiResult.setSuccess(result.isSuccess()); context.future.complete(apiResult); return null; }
private AsyncCallFuture<TemplateApiResult> syncToRegionStoreAsync(TemplateInfo template, DataStore store) { AsyncCallFuture<TemplateApiResult> future = new AsyncCallFuture<TemplateApiResult>(); // no need to create entry on template_store_ref here, since entries are already created when prepareSecondaryStorageForMigration is invoked. // But we need to set default install path so that sync can be done in the right s3 path TemplateInfo templateOnStore = _templateFactory.getTemplate(template, store); String installPath = TemplateConstants.DEFAULT_TMPLT_ROOT_DIR + "/" + TemplateConstants.DEFAULT_TMPLT_FIRST_LEVEL_DIR + template.getAccountId() + "/" + template.getId() + "/" + template.getUniqueName(); ((TemplateObject)templateOnStore).setInstallPath(installPath); TemplateOpContext<TemplateApiResult> context = new TemplateOpContext<TemplateApiResult>(null, (TemplateObject)templateOnStore, future); AsyncCallbackDispatcher<TemplateServiceImpl, CopyCommandResult> caller = AsyncCallbackDispatcher.create(this); caller.setCallback(caller.getTarget().syncTemplateCallBack(null, null)).setContext(context); _motionSrv.copyAsync(template, templateOnStore, caller); return future; }
@Override protected void runInContext() { Answer answer = sendMessage(cmd); callback.complete(answer); } }
protected Void copyManagedTemplateCallback(AsyncCallbackDispatcher<VolumeServiceImpl, CopyCommandResult> callback, CreateBaseImageContext<VolumeApiResult> context) { CopyCommandResult result = callback.getResult(); VolumeApiResult res = new VolumeApiResult(context.getVolume()); res.setResult(result.getResult()); AsyncCallFuture<VolumeApiResult> future = context.getFuture(); DataObject templateOnPrimaryStoreObj = context.destObj; if (result.isSuccess()) { templateOnPrimaryStoreObj.processEvent(Event.OperationSuccessed, result.getAnswer()); } else { templateOnPrimaryStoreObj.processEvent(Event.OperationFailed); } future.complete(res); return null; }
@Override public void copyAsync(Map<VolumeInfo, DataStore> volumeMap, VirtualMachineTO vmTo, Host srcHost, Host destHost, AsyncCompletionCallback<CopyCommandResult> callback) { CopyCommandResult result = new CopyCommandResult(null, null); result.setResult("Unsupported operation requested for copying data."); callback.complete(result); } }
protected Void createVolumeCallback(AsyncCallbackDispatcher<VolumeServiceImpl, CreateCmdResult> callback, CreateVolumeContext<VolumeApiResult> context) { CreateCmdResult result = callback.getResult(); DataObject vo = context.getVolume(); String errMsg = null; if (result.isSuccess()) { vo.processEvent(Event.OperationSuccessed, result.getAnswer()); } else { vo.processEvent(Event.OperationFailed); errMsg = result.getResult(); } VolumeApiResult volResult = new VolumeApiResult((VolumeObject)vo); if (errMsg != null) { volResult.setResult(errMsg); } context.getFuture().complete(volResult); return null; }
private void invokeCallback(String errMsg, AsyncCompletionCallback<CopyCommandResult> callback) { CopyCmdAnswer copyCmdAnswer = new CopyCmdAnswer(errMsg); CopyCommandResult result = new CopyCommandResult(null, copyCmdAnswer); result.setResult(errMsg); callback.complete(result); }
protected Void createManagedTemplateImageCallback(AsyncCallbackDispatcher<VolumeServiceImpl, CreateCmdResult> callback, CreateVolumeContext<CreateCmdResult> context) { CreateCmdResult result = callback.getResult(); VolumeApiResult res = new VolumeApiResult(null); res.setResult(result.getResult()); AsyncCallFuture<VolumeApiResult> future = context.getFuture(); DataObject templateOnPrimaryStoreObj = context.getVolume(); if (result.isSuccess()) { ((TemplateObject)templateOnPrimaryStoreObj).setInstallPath(result.getPath()); templateOnPrimaryStoreObj.processEvent(Event.OperationSuccessed, result.getAnswer()); } else { templateOnPrimaryStoreObj.processEvent(Event.OperationFailed); } future.complete(res); return null; }
@DB protected Void copyBaseImageCallback(AsyncCallbackDispatcher<VolumeServiceImpl, CopyCommandResult> callback, CreateBaseImageContext<VolumeApiResult> context) { CopyCommandResult result = callback.getResult(); VolumeApiResult res = new VolumeApiResult(context.getVolume()); AsyncCallFuture<VolumeApiResult> future = context.getFuture(); DataObject templateOnPrimaryStoreObj = context.destObj; if (!result.isSuccess()) { templateOnPrimaryStoreObj.processEvent(Event.OperationFailed); res.setResult(result.getResult()); future.complete(res); return null; } templateOnPrimaryStoreObj.processEvent(Event.OperationSuccessed, result.getAnswer()); createVolumeFromBaseImageAsync(context.volume, templateOnPrimaryStoreObj, context.dataStore, future); return null; }