@Override public RpcResult<Void> apply(Void input) { return RpcResultBuilder.<Void>success().build(); } });
/** * Return a result of send-barrier RPC. * * @return The result of send-barrier RPC. */ @Override public RpcResult<Void> call() { return RpcResultBuilder.success((Void)null).build(); } }
@Override public void onFailure(Throwable error) { String msg = String.format("Unable to write HwVtep {} to datastore", node_id); LOG.error("Unable to write HwVtep {}, {} to datastore", node_id , hwIp); result.set(RpcResultBuilder.<Void>failed().withError(RpcError.ErrorType.APPLICATION, msg, error).build()); } });
@Override public Future<RpcResult<Void>> updateMapping(UpdateMappingInput input) { LOG.trace("RPC received to update the following mapping: " + input.toString()); Preconditions.checkNotNull(input, "update-mapping RPC input must be not null!"); RpcResultBuilder<Void> rpcResultBuilder; dsbe.updateMapping(RPCInputConvertorUtil.toMapping(input)); rpcResultBuilder = RpcResultBuilder.success(); return Futures.immediateFuture(rpcResultBuilder.build()); }
@Override public void onSuccess(final Void result) { futureResult.set(RpcResultBuilder.<UpdateAlertFieldContentRuleOutput> success( updateAlertFieldContentRuleOutputBuilder.build()).build()); }
@Override public void onSuccess(final Void result) { futureResult.set(RpcResultBuilder.<UpdateAlertFieldValueRuleOutput> success( updateAlertFieldValueRuleOutputBuilder.build()).build()); }
@Override public void onSuccess(final Void result) { futureResult.set(RpcResultBuilder.<DeleteAlertFieldValueRuleOutput> success( deleteAlertFieldValueRuleOutputBuilder.build()).build()); }
@Override public Future<RpcResult<Void>> addMapping(AddMappingInput input) { Preconditions.checkNotNull(input, "add-mapping RPC input must be not null!"); LOG.trace("RPC received to add the following mapping: " + input.toString()); dsbe.addMapping(RPCInputConvertorUtil.toMapping(input)); RpcResultBuilder<Void> rpcResultBuilder; rpcResultBuilder = RpcResultBuilder.success(); return Futures.immediateFuture(rpcResultBuilder.build()); }
@Override public Future<RpcResult<Void>> removeMapping(RemoveMappingInput input) { Preconditions.checkNotNull(input, "remove-mapping RPC input must be not null!"); LOG.trace("RPC received to remove the following mapping: " + input.toString()); RpcResultBuilder<Void> rpcResultBuilder; dsbe.removeMapping(RPCInputConvertorUtil.toMapping(input)); rpcResultBuilder = RpcResultBuilder.success(); return Futures.immediateFuture(rpcResultBuilder.build()); }
/** * @param e connection exception * @param <T> rpc result return type * @return error wrapped inside {@link RpcResult} which is wrapped inside future */ public static <T> SettableFuture<RpcResult<T>> getRpcErrorFuture(ConnectionException e) { List<RpcError> rpcErrorList = wrapConnectionErrorIntoRpcErrors(e); SettableFuture<RpcResult<T>> futureWithError = SettableFuture.create(); futureWithError.set(RpcResultBuilder.<T>failed().withRpcErrors(rpcErrorList).build()); return futureWithError; }
@Override public ListenableFuture<RpcResult<GlobalRpcBenchOutput>> globalRpcBench(final GlobalRpcBenchInput input) { GlobalRpcBenchOutput output = new GlobalRpcBenchOutputBuilder(input).build(); RpcResult<GlobalRpcBenchOutput> result = RpcResultBuilder.success(output).build(); numRpcs++; return Futures.immediateFuture(result); }
@Override public ListenableFuture<RpcResult<Void>> apply(Void submitResult) throws Exception { fabricObj.notifyRouteUpdated(routesIId.firstIdentifierOf(Node.class), routes, true); return Futures.immediateFuture(RpcResultBuilder.<Void>success().build()); } }, executor);
@Override public Future<RpcResult<Void>> populateFibOnDpn(PopulateFibOnDpnInput input) { fibManager.populateFibOnNewDpn(input.getDpid(), input.getVpnId(), input.getRd(), null); return Futures.immediateFuture(RpcResultBuilder.<Void>success().build()); }
@Override public Future<RpcResult<SubscribeTestOutput>> subscribeTest(SubscribeTestInput input) { // TODO Auto-generated method stub final SettableFuture<RpcResult<SubscribeTestOutput>> futureResult = SettableFuture.create(); publishToURL(input.getAlertID(), input.getStreamID(), input.getMessage()); futureResult.set(RpcResultBuilder.<SubscribeTestOutput> success( new SubscribeTestOutputBuilder().setStatus("SUCCESS").build()).build()); return futureResult; }
@Override public ListenableFuture<RpcResult<ComposeFabricOutput>> apply(Void submitResult) throws Exception { RpcResultBuilder<ComposeFabricOutput> resultBuilder = RpcResultBuilder.<ComposeFabricOutput>success(); ComposeFabricOutputBuilder outputBuilder = new ComposeFabricOutputBuilder(); outputBuilder.setFabricId(fabricId); FabricInstanceCache.INSTANCE.retrieveFabric(fabricId).notifyFabricCreated(fabricNode); return Futures.immediateFuture(resultBuilder.withResult(outputBuilder.build()).build()); } });
/** * Return the value to be retuned by the task on successful completion. * * @return The output of the remove-flow RPC request. */ @Override protected final RpcResult<RemoveFlowOutput> getResult() { RemoveFlowOutput output = new RemoveFlowOutputBuilder(). setTransactionId(targetNode.createTransactionId()).build(); return RpcResultBuilder.success(output).build(); }
public static <T> ListenableFuture<RpcResult<T>> closeRequestContextWithRpcError(final RequestContext<T> requestContext, final String errorMessage) { RpcResultBuilder<T> rpcResultBuilder = RpcResultBuilder.<T>failed().withRpcError(RpcResultBuilder.newError(RpcError.ErrorType.APPLICATION, "", errorMessage)); requestContext.setResult(rpcResultBuilder.build()); closeRequstContext(requestContext); return requestContext.getFuture(); }
@Override public RpcResult<UpdateMeterOutput> apply(final RpcResult<Void> inputArg) { UpdateMeterOutputBuilder meterModOutput = new UpdateMeterOutputBuilder(); BigInteger bigIntXid = BigInteger.valueOf(input.getXid()); meterModOutput.setTransactionId(new TransactionId(bigIntXid)); UpdateMeterOutput result = meterModOutput.build(); RpcResult<UpdateMeterOutput> rpcResult = RpcResultBuilder .<UpdateMeterOutput>status(inputArg.isSuccessful()).withResult(result) .withRpcErrors(inputArg.getErrors()).build(); return rpcResult; } });
private RpcResult<GenerateSequenceOutput> buildFailureResponse(String errorMessage){ GenerateSequenceOutputBuilder sequenceGeneratorOutputBuilder=new GenerateSequenceOutputBuilder(); StatusBuilder statusBuilder =new StatusBuilder(); statusBuilder.setCode(401); statusBuilder.setMessage(errorMessage); sequenceGeneratorOutputBuilder.setStatus(statusBuilder.build()); return RpcResultBuilder .<GenerateSequenceOutput> status(true) .withResult(sequenceGeneratorOutputBuilder.build()) .build(); } }