@Nonnull @Override public CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(@Nonnull final SchemaPath type, final NormalizedNode<?, ?> input) { final CheckedFuture<DOMRpcResult, DOMRpcException> domRpcResultDOMRpcExceptionCheckedFuture = deviceRpc.invokeRpc(type, input); Futures.addCallback(domRpcResultDOMRpcExceptionCheckedFuture, resetKeepaliveTask); return domRpcResultDOMRpcExceptionCheckedFuture; }
@Override public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(@Nonnull final T listener) { // There is no real communication with the device (yet), no reset here return deviceRpc.registerRpcListener(listener); } }
@Nonnull @Override public CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(@Nonnull final SchemaPath type, @Nullable final NormalizedNode<?, ?> input) { return rpcService.invokeRpc(type, input); }
@Nonnull @Override public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(@Nonnull final T listener) { return rpcService.registerRpcListener(listener); } }
@Override public CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(final SchemaPath type, final NormalizedNode<?, ?> input) { return delegate().invokeRpc(type, input); }
@Override public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(final T listener) { return delegate().registerRpcListener(listener); } }
public ListenableFuture<DOMRpcResult> commit(final FutureCallback<DOMRpcResult> callback) { Preconditions.checkNotNull(callback); final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(toPath(NetconfMessageTransformUtil.NETCONF_COMMIT_QNAME), NetconfMessageTransformUtil.COMMIT_RPC_CONTENT); Futures.addCallback(future, callback); return future; }
@Override public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(final T listener) { return delegate().registerRpcListener(listener); } }
@Override public CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(final SchemaPath type, final NormalizedNode<?, ?> input) { return delegate().invokeRpc(type, input); }
private void retrievedDOMRpcService(DOMRpcService domRpcService) { LOG.debug("{}: retrievedDOMRpcService", logName()); rpcListenerReg = domRpcService.registerRpcListener(new DOMRpcAvailabilityListener() { @Override public void onRpcAvailable(Collection<DOMRpcIdentifier> rpcs) { onRpcsAvailable(rpcs); } @Override public void onRpcUnavailable(Collection<DOMRpcIdentifier> rpcs) { } }); }
public ListenableFuture<DOMRpcResult> discardChanges(final FutureCallback<DOMRpcResult> callback) { Preconditions.checkNotNull(callback); final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(toPath(NETCONF_DISCARD_CHANGES_QNAME), null); Futures.addCallback(future, callback); return future; }
@Override public <T extends org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(final T listener) { final ListenerRegistration<?> reg = delegate().registerRpcListener(new DOMRpcAvailabilityListener() { @Override public void onRpcAvailable(final Collection<DOMRpcIdentifier> rpcs) { listener.onRpcAvailable(convert(rpcs)); } @Override public void onRpcUnavailable(final Collection<DOMRpcIdentifier> rpcs) { listener.onRpcUnavailable(convert(rpcs)); } }); return new AbstractListenerRegistration<T>(listener) { @Override protected void removeRegistration() { reg.close(); } }; }
public ListenableFuture<DOMRpcResult> copyConfig(final FutureCallback<DOMRpcResult> callback, final QName source, final QName target) { Preconditions.checkNotNull(callback); Preconditions.checkNotNull(source); Preconditions.checkNotNull(target); final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(toPath(NetconfMessageTransformUtil.NETCONF_COPY_CONFIG_QNAME), getCopyConfigContent(source, target)); Futures.addCallback(future, callback); return future; }
private void startListeners() { LOG.debug("Registers rpc listeners"); rpcListener = new RpcListener(rpcRegistry); rpcImplementation = new RemoteRpcImplementation(rpcRegistry, config); rpcServices.registerRpcListener(rpcListener); registerRoutedRpcDelegate(); announceSupportedRpcs(); }
public ListenableFuture<DOMRpcResult> editConfig(final FutureCallback<? super DOMRpcResult> callback, final QName datastore, final DataContainerChild<?, ?> editStructure, final Optional<ModifyAction> modifyAction, final boolean rollback) { Preconditions.checkNotNull(editStructure); Preconditions.checkNotNull(callback); Preconditions.checkNotNull(datastore); final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(toPath(NETCONF_EDIT_CONFIG_QNAME), getEditConfigContent(datastore, editStructure, modifyAction, rollback)); Futures.addCallback(future, callback); return future; }
@Override public void run() { LOG.trace("{}: Invoking keepalive RPC", id); try { if(previousKeepalive != null && !previousKeepalive.isDone()) { onFailure(new IllegalStateException("Previous keepalive timed out")); } else { Futures.addCallback(currentDeviceRpc.invokeRpc(PATH, KEEPALIVE_PAYLOAD), this); } } catch (NullPointerException e) { LOG.debug("{}: Skipping keepalive while reconnecting", id); // Empty catch block intentional // Do nothing. The currentDeviceRpc was null and it means we hit the reconnect window and // attempted to send keepalive while we were reconnecting. Next keepalive will be scheduled // after reconnect so no action necessary here. } }
public ListenableFuture<DOMRpcResult> lock(final FutureCallback<DOMRpcResult> callback, final QName datastore) { Preconditions.checkNotNull(callback); Preconditions.checkNotNull(datastore); final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(toPath(NETCONF_LOCK_QNAME), getLockContent(datastore)); Futures.addCallback(future, callback); return future; }
public ListenableFuture<DOMRpcResult> validate(final FutureCallback<DOMRpcResult> callback, final QName datastore) { Preconditions.checkNotNull(callback); Preconditions.checkNotNull(datastore); final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(toPath(NetconfMessageTransformUtil.NETCONF_VALIDATE_QNAME), getValidateContent(datastore)); Futures.addCallback(future, callback); return future; }
public ListenableFuture<DOMRpcResult> unlock(final FutureCallback<DOMRpcResult> callback, final QName datastore) { Preconditions.checkNotNull(callback); Preconditions.checkNotNull(datastore); final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(toPath(NETCONF_UNLOCK_QNAME), getUnLockContent(datastore)); Futures.addCallback(future, callback); return future; }
public ListenableFuture<DOMRpcResult> unlockRunning(final FutureCallback<DOMRpcResult> callback) { final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(toPath(NETCONF_UNLOCK_QNAME), getUnLockContent(NETCONF_RUNNING_QNAME)); Futures.addCallback(future, callback); return future; }