import java.net.SocketAddress;
import java.security.PublicKey;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
/**
* Provider responsible for resolving CallHomeAuthorization.
*/
public interface CallHomeAuthorizationProvider {
-
/**
* Provides authorization parameters for incoming call-home connection.
*
* @param serverKey SSH key provided by SSH server on incoming connection
* @return {@link CallHomeAuthorization} with authorization information.
*/
- @Nonnull
- CallHomeAuthorization provideAuth(@Nonnull SocketAddress remoteAddress, @Nonnull PublicKey serverKey);
-
+ @NonNull CallHomeAuthorization provideAuth(@NonNull SocketAddress remoteAddress, @NonNull PublicKey serverKey);
}
package org.opendaylight.netconf.callhome.protocol;
import io.netty.util.concurrent.Promise;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.netconf.client.NetconfClientSession;
import org.opendaylight.netconf.client.NetconfClientSessionListener;
* @param listener Client Session Listener to be attached to NETCONF session.
* @return Promise with negotiated NETCONF session
*/
- @Nonnull
- Promise<NetconfClientSession> activate(@Nonnull NetconfClientSessionListener listener);
+ @NonNull Promise<NetconfClientSession> activate(@NonNull NetconfClientSessionListener listener);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netconf.callhome.protocol;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Throwables;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import io.netty.channel.EventLoopGroup;
import io.netty.util.concurrent.GlobalEventExecutor;
import io.netty.util.concurrent.Promise;
import java.security.PublicKey;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
-import javax.annotation.Nullable;
import javax.annotation.concurrent.GuardedBy;
import org.apache.sshd.client.channel.ClientChannel;
import org.apache.sshd.client.future.AuthFuture;
import org.apache.sshd.client.session.ClientSessionImpl;
import org.apache.sshd.common.future.SshFutureListener;
import org.apache.sshd.common.session.Session;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.netconf.client.NetconfClientSession;
import org.opendaylight.netconf.client.NetconfClientSessionListener;
import org.opendaylight.netconf.client.NetconfClientSessionNegotiatorFactory;
CallHomeSessionContext(final ClientSession sshSession, final CallHomeAuthorization authorization,
final SocketAddress remoteAddress, final Factory factory) {
- this.authorization = Preconditions.checkNotNull(authorization, "authorization");
- Preconditions.checkArgument(this.authorization.isServerAllowed(), "Server was not allowed.");
- Preconditions.checkArgument(sshSession instanceof ClientSessionImpl,
+ this.authorization = requireNonNull(authorization, "authorization");
+ checkArgument(this.authorization.isServerAllowed(), "Server was not allowed.");
+ checkArgument(sshSession instanceof ClientSessionImpl,
"sshSession must implement ClientSessionImpl");
- this.factory = Preconditions.checkNotNull(factory, "factory");
+ this.factory = requireNonNull(factory, "factory");
this.sshSession = (ClientSessionImpl) sshSession;
this.sshSession.setAttribute(SESSION_KEY, this);
this.remoteAddress = (InetSocketAddress) this.sshSession.getIoSession().getRemoteAddress();
netconfChannel.setStreaming(ClientChannel.Streaming.Async);
netconfChannel.open().addListener(newSshFutureListener(netconfChannel));
} catch (IOException e) {
- throw Throwables.propagate(e);
+ throw new IllegalStateException(e);
}
}
Factory(final EventLoopGroup nettyGroup, final NetconfClientSessionNegotiatorFactory negotiatorFactory,
final CallHomeNetconfSubsystemListener subsystemListener) {
- this.nettyGroup = Preconditions.checkNotNull(nettyGroup, "nettyGroup");
- this.negotiatorFactory = Preconditions.checkNotNull(negotiatorFactory, "negotiatorFactory");
- this.subsystemListener = Preconditions.checkNotNull(subsystemListener);
+ this.nettyGroup = requireNonNull(nettyGroup, "nettyGroup");
+ this.negotiatorFactory = requireNonNull(negotiatorFactory, "negotiatorFactory");
+ this.subsystemListener = requireNonNull(subsystemListener);
}
void remove(final CallHomeSessionContext session) {
return this.subsystemListener;
}
- @Nullable
- CallHomeSessionContext createIfNotExists(final ClientSession sshSession,
+ @Nullable CallHomeSessionContext createIfNotExists(final ClientSession sshSession,
final CallHomeAuthorization authorization, final SocketAddress remoteAddress) {
CallHomeSessionContext session = new CallHomeSessionContext(sshSession, authorization,
remoteAddress, this);
import java.util.Collection;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
-import javax.annotation.Nonnull;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.DataObjectModification;
import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
statusReporter = new CallhomeStatusReporter(broker);
}
- @Nonnull
@Override
- public CallHomeAuthorization provideAuth(@Nonnull final SocketAddress remoteAddress,
- @Nonnull final PublicKey serverKey) {
+ public CallHomeAuthorization provideAuth(final SocketAddress remoteAddress, final PublicKey serverKey) {
Device deviceSpecific = deviceConfig.get(serverKey);
String sessionName;
Credentials deviceCred;
private final ConcurrentMap<PublicKey, Device> byPublicKey = new ConcurrentHashMap<>();
@Override
- public void onDataTreeChanged(@Nonnull final Collection<DataTreeModification<Device>> mods) {
+ public void onDataTreeChanged(final Collection<DataTreeModification<Device>> mods) {
for (DataTreeModification<Device> dataTreeModification : mods) {
DataObjectModification<Device> rootNode = dataTreeModification.getRootNode();
process(rootNode);
private final ConcurrentMap<String, Device> byPublicKey = new ConcurrentHashMap<>();
@Override
- public void onDataTreeChanged(@Nonnull final Collection<DataTreeModification<Device>> mods) {
+ public void onDataTreeChanged(final Collection<DataTreeModification<Device>> mods) {
for (DataTreeModification<Device> dataTreeModification : mods) {
DataObjectModification<Device> rootNode = dataTreeModification.getRootNode();
process(rootNode);
private volatile Global current = null;
@Override
- public void onDataTreeChanged(@Nonnull final Collection<DataTreeModification<Global>> mods) {
+ public void onDataTreeChanged(final Collection<DataTreeModification<Global>> mods) {
for (DataTreeModification<Global> dataTreeModification : mods) {
current = dataTreeModification.getRootNode().getDataAfter();
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netconf.callhome.mount;
import com.google.common.collect.Multimap;
import java.util.Collection;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.netconf.callhome.mount.CallHomeMountSessionContext.CloseCallback;
import org.opendaylight.netconf.callhome.protocol.CallHomeChannelActivator;
import org.opendaylight.netconf.callhome.protocol.CallHomeProtocolSessionContext;
private final Multimap<PublicKey, CallHomeMountSessionContext> contextByPublicKey = MultimapBuilder.hashKeys()
.hashSetValues().build();
- @Nullable
- public CallHomeMountSessionContext getByAddress(InetSocketAddress remoteAddr) {
+ public @Nullable CallHomeMountSessionContext getByAddress(InetSocketAddress remoteAddr) {
return contextByAddress.get(remoteAddr);
}
- @Nullable
- public Collection<CallHomeMountSessionContext> getByPublicKey(PublicKey publicKey) {
+
+ public @NonNull Collection<CallHomeMountSessionContext> getByPublicKey(PublicKey publicKey) {
return contextByPublicKey.get(publicKey);
}
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
-import javax.annotation.Nullable;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.dom.DOMSource;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.api.DocumentedException;
* @return parsed rpc into normalized node, or null if input schema is null
*/
@SuppressWarnings("checkstyle:IllegalCatch")
- @Nullable
- private NormalizedNode<?, ?> rpcToNNode(final XmlElement element, @Nullable final ContainerSchemaNode input)
- throws DocumentedException {
+ private @Nullable NormalizedNode<?, ?> rpcToNNode(final XmlElement element,
+ final @Nullable ContainerSchemaNode input) throws DocumentedException {
if (input == null || input.getChildNodes().isEmpty()) {
return null;
}
import java.util.Collection;
import java.util.Collections;
import java.util.Set;
-import javax.annotation.Nonnull;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.DataObjectModification;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
private static final Logger LOG = LoggerFactory.getLogger(CapabilityChangeNotificationProducer.class);
private final BaseNotificationPublisherRegistration baseNotificationPublisherRegistration;
- private final ListenerRegistration capabilityChangeListenerRegistration;
+ private final ListenerRegistration<?> capabilityChangeListenerRegistration;
public CapabilityChangeNotificationProducer(final NetconfNotificationCollector netconfNotificationCollector,
final DataBroker dataBroker) {
}
@Override
- public void onDataTreeChanged(@Nonnull final Collection<DataTreeModification<Capabilities>> changes) {
+ public void onDataTreeChanged(final Collection<DataTreeModification<Capabilities>> changes) {
for (DataTreeModification<Capabilities> change : changes) {
final DataObjectModification<Capabilities> rootNode = change.getRootNode();
final DataObjectModification.ModificationType modificationType = rootNode.getModificationType();
*/
package org.opendaylight.netconf.mdsal.notification.impl;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+
import java.util.Collection;
-import javax.annotation.Nonnull;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.DataObjectModification;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
private final BaseNotificationPublisherRegistration baseNotificationPublisherRegistration;
- private final ListenerRegistration sessionListenerRegistration;
+ private final ListenerRegistration<?> sessionListenerRegistration;
public SessionNotificationProducer(final NetconfNotificationCollector netconfNotificationCollector,
final DataBroker dataBroker) {
@SuppressWarnings("checkstyle:MissingSwitchDefault")
@Override
- public void onDataTreeChanged(@Nonnull final Collection<DataTreeModification<Session>> changes) {
+ public void onDataTreeChanged(final Collection<DataTreeModification<Session>> changes) {
for (DataTreeModification<Session> change : changes) {
final DataObjectModification<Session> rootNode = change.getRootNode();
final DataObjectModification.ModificationType modificationType = rootNode.getModificationType();
}
private void publishStartedSession(final DataObject dataObject) {
- Preconditions.checkArgument(dataObject instanceof Session);
+ checkArgument(dataObject instanceof Session);
Session session = (Session) dataObject;
final NetconfSessionStart sessionStart = new NetconfSessionStartBuilder()
.setSessionId(new SessionIdOrZeroType(session.getSessionId()))
}
private void publishEndedSession(final DataObject dataObject) {
- Preconditions.checkArgument(dataObject instanceof Session);
+ checkArgument(dataObject instanceof Session);
Session session = (Session) dataObject;
final NetconfSessionEnd sessionEnd = new NetconfSessionEndBuilder()
.setSessionId(new SessionIdOrZeroType(session.getSessionId()))
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netconf.mdsal.notification.impl;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.verify;
import java.util.Collection;
-import javax.annotation.Nonnull;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.MockitoAnnotations;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
final OperationalDatastoreListener<DataObject> op =
new OperationalDatastoreListener<DataObject>(instanceIdentifier) {
@Override
- public void onDataTreeChanged(@Nonnull final Collection collection) {
+ public void onDataTreeChanged(final Collection<DataTreeModification<DataObject>> collection) {
}
};
doReturn(null).when(dataBroker).registerDataTreeChangeListener(any(), any());
assertEquals(testId, argumentId.getValue());
}
-
}
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
-import com.google.common.base.Function;
import com.google.common.collect.Lists;
import java.time.Instant;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nullable;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
public void testGetAvailableStreams() throws Exception {
final List<Stream> availableStreams = mount.getAvailableStreams();
Assert.assertEquals(2, availableStreams.size());
- final List<String> streamNames = Lists.transform(availableStreams, new Function<Stream, String>() {
- @Nullable
- @Override
- public String apply(@Nullable final Stream input) {
- return input.getName().getValue();
- }
- });
+ final List<String> streamNames = Lists.transform(availableStreams, input -> input.getName().getValue());
streamNames.contains(STREAM_1);
streamNames.contains(STREAM_2);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netconf.console.commands;
import com.google.common.annotations.VisibleForTesting;
import java.util.Map;
-import javax.annotation.Nonnull;
import org.apache.karaf.shell.api.action.Action;
import org.apache.karaf.shell.api.action.Command;
import org.apache.karaf.shell.api.action.lifecycle.Reference;
import org.apache.karaf.shell.api.action.lifecycle.Service;
import org.apache.karaf.shell.support.table.ShellTable;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.netconf.console.api.NetconfCommands;
import org.opendaylight.netconf.console.utils.NetconfConsoleConstants;
}
@SuppressWarnings("checkstyle:RegexpSinglelineJava")
- private static void printDevicesList(@Nonnull final Map<String, Map<String, String>> allDevices) {
+ private static void printDevicesList(final @NonNull Map<String, Map<String, String>> allDevices) {
final ShellTable table = new ShellTable();
table.column(NetconfConsoleConstants.NETCONF_ID).alignLeft();
table.column(NetconfConsoleConstants.NETCONF_IP).alignLeft();
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netconf.console.commands;
import com.google.common.annotations.VisibleForTesting;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import javax.annotation.Nonnull;
import org.apache.karaf.shell.api.action.Action;
import org.apache.karaf.shell.api.action.Command;
import org.apache.karaf.shell.api.action.Option;
import org.apache.karaf.shell.api.action.lifecycle.Reference;
import org.apache.karaf.shell.api.action.lifecycle.Service;
import org.apache.karaf.shell.support.table.ShellTable;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.netconf.console.api.NetconfCommands;
import org.opendaylight.netconf.console.utils.NetconfConsoleConstants;
}
@SuppressWarnings("checkstyle:RegexpSinglelineJava")
- private static void printDeviceData(@Nonnull final Map<String, Map<String, List<String>>> devices) {
+ private static void printDeviceData(final @NonNull Map<String, Map<String, List<String>>> devices) {
final ShellTable table = new ShellTable();
table.column(NetconfConsoleConstants.NETCONF_ID).alignLeft();
table.column(NetconfConsoleConstants.NETCONF_IP).alignLeft();
import akka.pattern.Patterns;
import akka.util.Timeout;
import java.util.Collection;
-import javax.annotation.Nonnull;
import javax.annotation.concurrent.GuardedBy;
import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataObjectModification;
}
@Override
- public void onDataTreeChanged(@Nonnull final Collection<DataTreeModification<Node>> changes) {
+ public void onDataTreeChanged(final Collection<DataTreeModification<Node>> changes) {
for (final DataTreeModification<Node> change : changes) {
final DataObjectModification<Node> rootNode = change.getRootNode();
final NodeId nodeId = NetconfTopologyUtils.getNodeId(rootNode.getIdentifier());
*/
package org.opendaylight.netconf.topology.singleton.impl;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.netconf.topology.singleton.impl.utils.NetconfTopologyUtils.DEFAULT_SCHEMA_REPOSITORY;
import akka.actor.ActorRef;
import akka.dispatch.OnComplete;
import akka.pattern.Patterns;
import akka.util.Timeout;
-import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.concurrent.atomic.AtomicBoolean;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
import org.opendaylight.netconf.topology.singleton.impl.utils.NetconfTopologyUtils;
import org.opendaylight.netconf.topology.singleton.messages.RefreshSetupMasterActorData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNode;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import scala.concurrent.Future;
NetconfTopologyContext(final NetconfTopologySetup netconfTopologyDeviceSetup,
final ServiceGroupIdentifier serviceGroupIdent,
final Timeout actorResponseWaitTime, final DOMMountPointService mountService) {
- this.netconfTopologyDeviceSetup = Preconditions.checkNotNull(netconfTopologyDeviceSetup);
+ this.netconfTopologyDeviceSetup = requireNonNull(netconfTopologyDeviceSetup);
this.serviceGroupIdent = serviceGroupIdent;
this.actorResponseWaitTime = actorResponseWaitTime;
this.mountService = mountService;
// called when master is down/changed to slave
@Override
- public ListenableFuture<Void> closeServiceInstance() {
+ public ListenableFuture<?> closeServiceInstance() {
if (!closed.get()) {
// in case that master changes role to slave, new NodeDeviceManager must be created and listener registered
}
stopDeviceConnectorAndActor();
- return Futures.immediateFuture(null);
+ return FluentFutures.immediateNullFluentFuture();
}
@Override
* Refresh, if configuration data was changed.
* @param setup new setup
*/
- void refresh(@Nonnull final NetconfTopologySetup setup) {
- netconfTopologyDeviceSetup = Preconditions.checkNotNull(setup);
+ void refresh(final @NonNull NetconfTopologySetup setup) {
+ netconfTopologyDeviceSetup = requireNonNull(setup);
remoteDeviceId = NetconfTopologyUtils.createRemoteDeviceId(netconfTopologyDeviceSetup.getNode().getNodeId(),
netconfTopologyDeviceSetup.getNode().augmentation(NetconfNode.class));
*/
package org.opendaylight.netconf.topology.singleton.impl;
+import static java.util.Objects.requireNonNull;
+
import akka.actor.ActorSystem;
import akka.util.Timeout;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
-import javax.annotation.Nonnull;
import org.opendaylight.aaa.encrypt.AAAEncryptionService;
import org.opendaylight.controller.cluster.ActorSystemProvider;
import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
final DOMMountPointService mountPointService,
final AAAEncryptionService encryptionService) {
- this.dataBroker = Preconditions.checkNotNull(dataBroker);
- this.rpcProviderRegistry = Preconditions.checkNotNull(rpcProviderRegistry);
- this.clusterSingletonServiceProvider = Preconditions.checkNotNull(clusterSingletonServiceProvider);
+ this.dataBroker = requireNonNull(dataBroker);
+ this.rpcProviderRegistry = requireNonNull(rpcProviderRegistry);
+ this.clusterSingletonServiceProvider = requireNonNull(clusterSingletonServiceProvider);
this.keepaliveExecutor = keepaliveExecutor.getExecutor();
this.processingExecutor = MoreExecutors.listeningDecorator(processingExecutor.getExecutor());
- this.actorSystem = Preconditions.checkNotNull(actorSystemProvider).getActorSystem();
- this.eventExecutor = Preconditions.checkNotNull(eventExecutor);
- this.clientDispatcher = Preconditions.checkNotNull(clientDispatcher);
- this.topologyId = Preconditions.checkNotNull(topologyId);
+ this.actorSystem = requireNonNull(actorSystemProvider).getActorSystem();
+ this.eventExecutor = requireNonNull(eventExecutor);
+ this.clientDispatcher = requireNonNull(clientDispatcher);
+ this.topologyId = requireNonNull(topologyId);
this.writeTxIdleTimeout = Duration.apply(config.getWriteTransactionIdleTimeout(), TimeUnit.SECONDS);
this.mountPointService = mountPointService;
- this.encryptionService = Preconditions.checkNotNull(encryptionService);
+ this.encryptionService = requireNonNull(encryptionService);
}
}
@Override
- public void onDataTreeChanged(@Nonnull final Collection<DataTreeModification<Node>> changes) {
+ public void onDataTreeChanged(final Collection<DataTreeModification<Node>> changes) {
for (final DataTreeModification<Node> change : changes) {
final DataObjectModification<Node> rootNode = change.getRootNode();
final InstanceIdentifier<Node> dataModifIdent = change.getRootPath().getRootIdentifier();
@SuppressWarnings("checkstyle:IllegalCatch")
private void startNetconfDeviceContext(final InstanceIdentifier<Node> instanceIdentifier, final Node node) {
final NetconfNode netconfNode = node.augmentation(NetconfNode.class);
- Preconditions.checkNotNull(netconfNode);
- Preconditions.checkNotNull(netconfNode.getHost());
- Preconditions.checkNotNull(netconfNode.getHost().getIpAddress());
+ requireNonNull(netconfNode);
+ requireNonNull(netconfNode.getHost());
+ requireNonNull(netconfNode.getHost().getIpAddress());
final Timeout actorResponseWaitTime = new Timeout(Duration.create(netconfNode.getActorResponseWaitTime(),
"seconds"));
}
@Override
- public void onFailure(@Nonnull final Throwable throwable) {
+ public void onFailure(final Throwable throwable) {
LOG.error("Unable to initialize netconf-topology, {}", throwable);
}
}, MoreExecutors.directExecutor());
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.SettableFuture;
import java.util.Collection;
-import javax.annotation.Nonnull;
import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
return settableFuture;
}
- @Nonnull
@Override
- public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(
- @Nonnull final T listener) {
+ public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(final T listener) {
// NOOP, only proxy
throw new UnsupportedOperationException("RegisterRpcListener: DOMRpc service not working in cluster.");
}
import akka.util.Timeout;
import java.util.Collections;
import java.util.Set;
-import javax.annotation.Nonnull;
import org.opendaylight.controller.cluster.schema.provider.RemoteYangTextSourceProvider;
import org.opendaylight.controller.cluster.schema.provider.impl.YangTextSchemaSourceSerializationProxy;
import org.opendaylight.netconf.topology.singleton.messages.YangTextSchemaSourceRequest;
@Override
public Future<YangTextSchemaSourceSerializationProxy> getYangTextSchemaSource(
- @Nonnull final SourceIdentifier sourceIdentifier) {
+ final SourceIdentifier sourceIdentifier) {
final Future<Object> scalaFuture = Patterns.ask(masterRef,
new YangTextSchemaSourceRequest(sourceIdentifier), actorResponseWaitTime);
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netconf.topology.singleton.impl;
+import static com.google.common.base.Preconditions.checkState;
import static java.util.Objects.isNull;
import static java.util.Objects.requireNonNull;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import java.util.List;
import java.util.Map;
import java.util.Optional;
-import javax.annotation.Nullable;
import org.opendaylight.aaa.encrypt.AAAEncryptionService;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.client.NetconfClientSessionListener;
}
@Override
- public void onFailure(@Nullable final Throwable throwable) {
+ public void onFailure(final Throwable throwable) {
LOG.error("{}: Connector failed", remoteDeviceId, throwable);
}
}, MoreExecutors.directExecutor());
//non-module capabilities should not exist in yang module capabilities
final NetconfSessionPreferences netconfSessionPreferences = NetconfSessionPreferences.fromStrings(capabilities);
- Preconditions.checkState(netconfSessionPreferences.getNonModuleCaps().isEmpty(),
+ checkState(netconfSessionPreferences.getNonModuleCaps().isEmpty(),
"List yang-module-capabilities/capability should contain only module based capabilities. "
+ "Non-module capabilities used: " + netconfSessionPreferences.getNonModuleCaps());
import java.io.IOException;
import java.util.List;
import java.util.stream.Collectors;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.cluster.common.actor.AbstractUntypedActor;
import org.opendaylight.controller.cluster.schema.provider.RemoteYangTextSourceProvider;
import org.opendaylight.controller.cluster.schema.provider.impl.RemoteSchemaProvider;
}
private void sendYangTextSchemaSourceProxy(final SourceIdentifier sourceIdentifier, final ActorRef sender) {
- final ListenableFuture<@NonNull YangTextSchemaSource> schemaSourceFuture =
+ final ListenableFuture<YangTextSchemaSource> schemaSourceFuture =
schemaRepository.getSchemaSource(sourceIdentifier, YangTextSchemaSource.class);
Futures.addCallback(schemaSourceFuture, new FutureCallback<YangTextSchemaSource>() {
}
@Override
- public void onFailure(@Nonnull final Throwable throwable) {
+ public void onFailure(final Throwable throwable) {
LOG.debug("{}: getSchemaSource for {} failed", id, sourceIdentifier, throwable);
sender.tell(new Failure(throwable), getSelf());
}
Futures.addCallback(rpcResult, new FutureCallback<DOMRpcResult>() {
@Override
- public void onSuccess(@Nullable final DOMRpcResult domRpcResult) {
+ public void onSuccess(final DOMRpcResult domRpcResult) {
LOG.debug("{}: invokeSlaveRpc for {}, domRpcResult: {}", id, schemaPath, domRpcResult);
if (domRpcResult == null) {
}
@Override
- public void onFailure(@Nonnull final Throwable throwable) {
+ public void onFailure(final Throwable throwable) {
recipient.tell(new Failure(throwable), getSelf());
}
}, MoreExecutors.directExecutor());
schemaContextFactory.createSchemaContext(sourceIdentifiers);
Futures.addCallback(schemaContextFuture, new FutureCallback<SchemaContext>() {
@Override
- public void onSuccess(@Nonnull final SchemaContext result) {
+ public void onSuccess(final SchemaContext result) {
executeInSelf(() -> {
// Make sure the slaveSalManager instance hasn't changed since we initiated the schema context
// resolution.
}
@Override
- public void onFailure(@Nonnull final Throwable throwable) {
+ public void onFailure(final Throwable throwable) {
executeInSelf(() -> {
if (slaveSalManager == localSlaveSalManager) {
final Throwable cause = Throwables.getRootCause(throwable);
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.Optional;
-import javax.annotation.Nonnull;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.netconf.topology.singleton.messages.NormalizedNodeMessage;
}
@Override
- public void onFailure(@Nonnull final Throwable throwable) {
+ public void onFailure(final Throwable throwable) {
sender.tell(new Failure(throwable), self);
}
}, MoreExecutors.directExecutor());
}
@Override
- public void onFailure(@Nonnull final Throwable throwable) {
+ public void onFailure(final Throwable throwable) {
sender.tell(new Failure(throwable), self);
}
}, MoreExecutors.directExecutor());
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.MoreExecutors;
-import javax.annotation.Nonnull;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.netconf.topology.singleton.messages.NormalizedNodeMessage;
}
@Override
- public void onFailure(@Nonnull final Throwable throwable) {
+ public void onFailure(final Throwable throwable) {
requester.tell(new Failure(throwable), self);
}
}, MoreExecutors.directExecutor());
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netconf.topology.singleton.messages.rpc;
import java.io.Externalizable;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.io.Serializable;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.netconf.topology.singleton.messages.NormalizedNodeMessage;
import org.opendaylight.netconf.topology.singleton.messages.SchemaPathMessage;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
private final NormalizedNodeMessage normalizedNodeMessage;
public InvokeRpcMessage(final SchemaPathMessage schemaPathMessage,
- @Nullable final NormalizedNodeMessage normalizedNodeMessage) {
+ final @Nullable NormalizedNodeMessage normalizedNodeMessage) {
this.schemaPathMessage = schemaPathMessage;
this.normalizedNodeMessage = normalizedNodeMessage;
}
return schemaPathMessage.getSchemaPath();
}
- @Nullable
- public NormalizedNodeMessage getNormalizedNodeMessage() {
+
+ public @Nullable NormalizedNodeMessage getNormalizedNodeMessage() {
return normalizedNodeMessage;
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netconf.topology.singleton.messages.rpc;
+import static java.util.Objects.requireNonNull;
+
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.io.Externalizable;
import java.io.IOException;
import java.io.Serializable;
import java.util.Collection;
import java.util.LinkedList;
-import java.util.Objects;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.netconf.topology.singleton.messages.NormalizedNodeMessage;
import org.opendaylight.yangtools.yang.common.RpcError;
private final Collection<? extends RpcError> rpcErrors;
private final NormalizedNodeMessage normalizedNodeMessage;
- public InvokeRpcMessageReply(@Nullable final NormalizedNodeMessage normalizedNodeMessage,
- @Nonnull final Collection<? extends RpcError> rpcErrors) {
+ public InvokeRpcMessageReply(final @Nullable NormalizedNodeMessage normalizedNodeMessage,
+ final @NonNull Collection<? extends RpcError> rpcErrors) {
this.normalizedNodeMessage = normalizedNodeMessage;
- this.rpcErrors = Objects.requireNonNull(rpcErrors);
+ this.rpcErrors = requireNonNull(rpcErrors);
}
- @Nullable
- public NormalizedNodeMessage getNormalizedNodeMessage() {
+ public @Nullable NormalizedNodeMessage getNormalizedNodeMessage() {
return normalizedNodeMessage;
}
- @Nonnull
- public Collection<? extends RpcError> getRpcErrors() {
+ public @NonNull Collection<? extends RpcError> getRpcErrors() {
return rpcErrors;
}
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.MoreExecutors;
-import javax.annotation.Nullable;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
transaction.put(LogicalDatastoreType.CONFIGURATION, nodePath, node);
transaction.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(@Nullable final CommitInfo result) {
+ public void onSuccess(final CommitInfo result) {
LOG.debug("Node {} was successfully added to the topology", instanceName);
}
import com.google.common.util.concurrent.MoreExecutors;
import io.netty.util.concurrent.EventExecutor;
import java.util.Collection;
-import javax.annotation.Nonnull;
import org.opendaylight.aaa.encrypt.AAAEncryptionService;
import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
import org.opendaylight.controller.config.threadpool.ThreadPool;
}
@Override
- public void onDataTreeChanged(@Nonnull final Collection<DataTreeModification<Node>> collection) {
+ public void onDataTreeChanged(final Collection<DataTreeModification<Node>> collection) {
for (final DataTreeModification<Node> change : collection) {
final DataObjectModification<Node> rootNode = change.getRootNode();
switch (rootNode.getModificationType()) {
import java.util.Collection;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nonnull;
import org.opendaylight.netconf.api.DocumentedException;
import org.opendaylight.netconf.api.NetconfDocumentedException;
import org.opendaylight.netconf.api.NetconfMessage;
import org.w3c.dom.Document;
public final class NetconfMessageUtil {
-
private static final Logger LOG = LoggerFactory.getLogger(NetconfMessageUtil.class);
- private NetconfMessageUtil() {}
+ private NetconfMessageUtil() {
+
+ }
public static boolean isOKMessage(final NetconfMessage message) throws NetconfDocumentedException {
return isOKMessage(message.getDocument());
}
List<XmlElement> caps = capabilitiesElement.get().getChildElements(XmlNetconfConstants.CAPABILITY);
- return Collections2.transform(caps, (@Nonnull final XmlElement input) -> {
+ return Collections2.transform(caps, input -> {
// Trim possible leading/tailing whitespace
try {
return input.getTextContent().trim();
*/
package org.opendaylight.netconf.sal.connect.netconf;
+import static com.google.common.base.Preconditions.checkState;
import static java.util.Objects.requireNonNull;
-import com.google.common.base.Preconditions;
import com.google.common.base.Predicates;
import com.google.common.collect.Collections2;
import com.google.common.collect.Lists;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
-import javax.annotation.Nonnull;
import javax.annotation.concurrent.GuardedBy;
import org.opendaylight.mdsal.dom.api.DOMNotification;
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
final FutureCallback<DeviceSources> resolvedSourceCallback = new FutureCallback<DeviceSources>() {
@Override
- public void onSuccess(@Nonnull final DeviceSources result) {
+ public void onSuccess(final DeviceSources result) {
addProvidedSourcesToSchemaRegistry(result);
setUpSchema(result);
}
final SchemaRepository schemaRepository,
final SchemaContextFactory schemaContextFactory,
final NetconfDeviceSchemasResolver deviceSchemasResolver) {
- this.schemaRegistry = Preconditions.checkNotNull(schemaRegistry);
- this.schemaRepository = Preconditions.checkNotNull(schemaRepository);
- this.schemaContextFactory = Preconditions.checkNotNull(schemaContextFactory);
- this.stateSchemasResolver = Preconditions.checkNotNull(deviceSchemasResolver);
+ this.schemaRegistry = requireNonNull(schemaRegistry);
+ this.schemaRepository = requireNonNull(schemaRepository);
+ this.schemaContextFactory = requireNonNull(schemaContextFactory);
+ this.stateSchemasResolver = requireNonNull(deviceSchemasResolver);
}
public SchemaSourceRegistry getSchemaRegistry() {
private Collection<SourceIdentifier> stripUnavailableSource(final Collection<SourceIdentifier> requiredSources,
final SourceIdentifier sourceIdToRemove) {
final LinkedList<SourceIdentifier> sourceIdentifiers = Lists.newLinkedList(requiredSources);
- final boolean removed = sourceIdentifiers.remove(sourceIdToRemove);
- Preconditions.checkState(
- removed, "{}: Trying to remove {} from {} failed", id, sourceIdToRemove, requiredSources);
+ checkState(sourceIdentifiers.remove(sourceIdToRemove),
+ "%s: Trying to remove %s from %s failed", id, sourceIdToRemove, requiredSources);
return sourceIdentifiers;
}
*/
package org.opendaylight.netconf.sal.connect.netconf.listener;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkState;
+
import com.google.common.util.concurrent.AbstractFuture;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import javax.annotation.Nullable;
final class UncancellableFuture<V> extends AbstractFuture<V> {
private volatile boolean uncancellable = false;
@SuppressFBWarnings(value = "NP_PARAMETER_MUST_BE_NONNULL_BUT_MARKED_AS_NULLABLE",
justification = "Unrecognised NullableDecl")
@Override
- public boolean set(@Nullable final V value) {
- Preconditions.checkState(uncancellable);
+ public boolean set(final V value) {
+ checkState(uncancellable);
return super.set(value);
}
@Override
protected boolean setException(final Throwable throwable) {
- Preconditions.checkState(uncancellable);
+ checkState(uncancellable);
return super.setException(throwable);
}
}
*/
package org.opendaylight.netconf.sal.connect.netconf.listener;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
/**
* DTO with user capabilities to override or merge with device specific capabilities.
private final boolean overrideModuleCapabilities;
private final boolean overrideNonModuleCapabilities;
- public UserPreferences(@Nonnull final NetconfSessionPreferences sessionPreferences,
+ public UserPreferences(final @NonNull NetconfSessionPreferences sessionPreferences,
boolean overrideModuleCapabilities, boolean overrideNonModuleCapabilities) {
if (overrideModuleCapabilities && (sessionPreferences.getModuleBasedCaps() == null
*/
package org.opendaylight.netconf.sal.connect.netconf.sal;
+import static com.google.common.base.Preconditions.checkState;
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfBaseOps.getSourceNode;
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_GET_CONFIG_NODEID;
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_GET_CONFIG_PATH;
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_RUNNING_QNAME;
-import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.dom.api.DOMActionService;
import org.opendaylight.mdsal.dom.api.DOMNotification;
import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
}
void reconnect() {
- Preconditions.checkState(listener != null, "%s: Unable to reconnect, session listener is missing", id);
+ checkState(listener != null, "%s: Unable to reconnect, session listener is missing", id);
stopKeepalives();
LOG.info("{}: Reconnecting inactive netconf session", id);
listener.disconnect();
private void scheduleKeepalives() {
lastKeepAliveSucceeded.set(true);
- Preconditions.checkState(currentDeviceRpc != null);
+ checkState(currentDeviceRpc != null);
LOG.trace("{}: Scheduling keepalives every {} {}", id, keepaliveDelaySeconds, TimeUnit.SECONDS);
currentKeepalive = executor.scheduleWithFixedDelay(new Keepalive(),
keepaliveDelaySeconds, keepaliveDelaySeconds, TimeUnit.SECONDS);
if (!lastJobSucceeded) {
onFailure(new IllegalStateException("Previous keepalive timed out"));
} else {
- Futures.addCallback(currentDeviceRpc.invokeRpc(NETCONF_GET_CONFIG_PATH, KEEPALIVE_PAYLOAD), this,
+ currentDeviceRpc.invokeRpc(NETCONF_GET_CONFIG_PATH, KEEPALIVE_PAYLOAD).addCallback(this,
MoreExecutors.directExecutor());
}
} catch (NullPointerException e) {
}
@Override
- public void onFailure(@Nonnull final Throwable throwable) {
+ public void onFailure(final Throwable throwable) {
LOG.warn("{}: Keepalive RPC failed. Reconnecting netconf session.", id, throwable);
reconnect();
}
*/
private class ResetKeepalive implements FutureCallback<DOMRpcResult> {
@Override
- public void onSuccess(@Nullable final DOMRpcResult result) {
+ public void onSuccess(final DOMRpcResult result) {
// No matter what response we got,
// rpc-reply or rpc-error, we got it from device so the netconf session is OK.
resetKeepalive();
}
@Override
- public void onFailure(@Nonnull final Throwable throwable) {
+ public void onFailure(final Throwable throwable) {
// User/Application RPC failed (The RPC did not reach the remote device or ..
// TODO what other reasons could cause this ?)
// There is no point in keeping this session. Reconnect.
return deviceRpc;
}
- @Nonnull
@Override
- public @NonNull FluentFuture<DOMRpcResult> invokeRpc(@Nonnull final SchemaPath type,
- final NormalizedNode<?, ?> input) {
+ public FluentFuture<DOMRpcResult> invokeRpc(final SchemaPath type, final NormalizedNode<?, ?> input) {
final FluentFuture<DOMRpcResult> rpcResultFuture = deviceRpc.invokeRpc(type, input);
- Futures.addCallback(rpcResultFuture, resetKeepaliveTask, MoreExecutors.directExecutor());
+ rpcResultFuture.addCallback(resetKeepaliveTask, MoreExecutors.directExecutor());
final RequestTimeoutTask timeoutTask = new RequestTimeoutTask(rpcResultFuture);
executor.schedule(timeoutTask, defaultRequestTimeoutMillis, TimeUnit.MILLISECONDS);
}
@Override
- public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(
- @Nonnull final T listener) {
+ public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(final T listener) {
// There is no real communication with the device (yet), no reset here
return deviceRpc.registerRpcListener(listener);
}
import com.google.common.collect.Lists;
import com.google.common.collect.Multimap;
import java.util.Collection;
-import javax.annotation.Nonnull;
import org.opendaylight.mdsal.dom.api.DOMNotification;
import org.opendaylight.mdsal.dom.api.DOMNotificationListener;
import org.opendaylight.mdsal.dom.api.DOMNotificationService;
@Override
public synchronized <T extends DOMNotificationListener> ListenerRegistration<T> registerNotificationListener(
- @Nonnull final T listener, @Nonnull final Collection<SchemaPath> types) {
+ final T listener, final Collection<SchemaPath> types) {
for (final SchemaPath type : types) {
listeners.put(type, listener);
}
@Override
public synchronized <T extends DOMNotificationListener> ListenerRegistration<T> registerNotificationListener(
- @Nonnull final T listener, final SchemaPath... types) {
+ final T listener, final SchemaPath... types) {
return registerNotificationListener(listener, Lists.newArrayList(types));
}
}
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.SettableFuture;
-import javax.annotation.Nonnull;
import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
return ret;
}
- @Nonnull
@Override
- public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(
- @Nonnull final T listener) {
+ public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(final T listener) {
listener.onRpcAvailable(Collections2.transform(schemaContext.getOperations(),
input -> DOMRpcIdentifier.create(input.getPath())));
import java.util.List;
import java.util.Map;
import java.util.Optional;
-import javax.annotation.Nonnull;
import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.DataObjectModification;
}
@Override
- public void onDataTreeChanged(@Nonnull final Collection<DataTreeModification<Keystore>> changes) {
+ public void onDataTreeChanged(final Collection<DataTreeModification<Keystore>> changes) {
LOG.debug("Keystore updated: {}", changes);
for (final DataTreeModification<Keystore> change : changes) {
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.SettableFuture;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
}
private FluentFuture<DOMRpcResult> handleRpc(
- @Nonnull final SchemaPath type, @Nullable final NormalizedNode<?, ?> input,
+ final @NonNull SchemaPath type, final @NonNull NormalizedNode<?, ?> input,
final MessageTransformer<NetconfMessage> transformer) {
final FluentFuture<RpcResult<NetconfMessage>> delegateFuture = listener.sendRequest(
transformer.toRpcRequest(type, input), type.getLastComponent());
return NetconfMessageTransformUtil.NETCONF_URI.equals(type.getLastComponent().getNamespace());
}
- @Nonnull
@Override
- public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(@Nonnull final T lsnr) {
+ public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(final T lsnr) {
throw new UnsupportedOperationException("Not available for netconf 1.0");
}
}
*/
package org.opendaylight.netconf.sal.connect.netconf.sal.tx;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkState;
+
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CopyOnWriteArrayList;
-import javax.annotation.Nonnull;
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
}
protected void checkNotFinished() {
- Preconditions.checkState(!isFinished(), "%s: Transaction %s already finished", id, getIdentifier());
+ checkState(!isFinished(), "%s: Transaction %s already finished", id, getIdentifier());
}
protected boolean isFinished() {
}
@Override
- public @NonNull FluentFuture<? extends @NonNull CommitInfo> commit() {
+ public FluentFuture<? extends CommitInfo> commit() {
final SettableFuture<CommitInfo> resultFuture = SettableFuture.create();
Futures.addCallback(commitConfiguration(), new FutureCallback<RpcResult<Void>>() {
@Override
final ListenableFuture<RpcResult<Void>> result = performCommit();
Futures.addCallback(result, new FutureCallback<RpcResult<Void>>() {
@Override
- public void onSuccess(@Nonnull final RpcResult<Void> rpcResult) {
+ public void onSuccess(final RpcResult<Void> rpcResult) {
if (rpcResult.isSuccessful()) {
listeners.forEach(txListener -> txListener.onTransactionSuccessful(AbstractWriteTx.this));
} else {
private void checkEditable(final LogicalDatastoreType store) {
checkNotFinished();
- Preconditions.checkArgument(store == LogicalDatastoreType.CONFIGURATION,
+ checkArgument(store == LogicalDatastoreType.CONFIGURATION,
"Can edit only configuration data, not %s", store);
}
Futures.addCallback(Futures.allAsList(resultsFutures), new FutureCallback<List<DOMRpcResult>>() {
@Override
- public void onSuccess(@Nonnull final List<DOMRpcResult> domRpcResults) {
+ public void onSuccess(final List<DOMRpcResult> domRpcResults) {
if (!transformed.isDone()) {
extractResult(domRpcResults, transformed);
}
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.Optional;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfBaseOps;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfRpcFutureCallback;
private void lock() {
final FutureCallback<DOMRpcResult> lockCandidateCallback = new FutureCallback<DOMRpcResult>() {
@Override
- public void onSuccess(@Nonnull final DOMRpcResult result) {
+ public void onSuccess(final DOMRpcResult result) {
if (isSuccess(result)) {
if (LOG.isTraceEnabled()) {
LOG.trace("Lock candidate successful");
Futures.addCallback(txResult, new FutureCallback<RpcResult<Void>>() {
@Override
- public void onSuccess(@Nullable final RpcResult<Void> result) {
+ public void onSuccess(final RpcResult<Void> result) {
cleanupOnSuccess();
}
package org.opendaylight.netconf.sal.connect.netconf.util;
import com.google.common.util.concurrent.FutureCallback;
-import javax.annotation.Nonnull;
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.slf4j.Logger;
}
@Override
- public void onSuccess(@Nonnull final DOMRpcResult result) {
+ public void onSuccess(final DOMRpcResult result) {
if (result.getErrors().isEmpty()) {
LOG.trace("{}: {} invoked successfully", id, type);
} else {
import java.util.Collections;
import java.util.Optional;
import java.util.Set;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
import org.opendaylight.netconf.api.capability.Capability;
import org.opendaylight.netconf.api.monitoring.NetconfManagementSession;
import org.opendaylight.netconf.api.monitoring.NetconfMonitoringService;
private static final Function<Capability, Uri> CAPABILITY_URI_FUNCTION =
capability -> new Uri(capability.getCapabilityUri());
- private static final Function<Capability, Schema> CAPABILITY_SCHEMA_FUNCTION = new Function<Capability, Schema>() {
- @Nullable
- @Override
- public Schema apply(@Nonnull final Capability capability) {
- return new SchemaBuilder()
- .setIdentifier(capability.getModuleName().get())
- .setNamespace(new Uri(capability.getModuleNamespace().get()))
- .setFormat(Yang.class)
- .setVersion(capability.getRevision().or(""))
- .setLocation(Collections.singletonList(new Location(Enumeration.NETCONF)))
- .withKey(new SchemaKey(Yang.class, capability.getModuleName().get(),
- capability.getRevision().or("")))
- .build();
- }
- };
+ private static final Function<Capability, Schema> CAPABILITY_SCHEMA_FUNCTION = capability -> new SchemaBuilder()
+ .setIdentifier(capability.getModuleName().get())
+ .setNamespace(new Uri(capability.getModuleNamespace().get()))
+ .setFormat(Yang.class)
+ .setVersion(capability.getRevision().or(""))
+ .setLocation(Collections.singletonList(new Location(Enumeration.NETCONF)))
+ .withKey(new SchemaKey(Yang.class, capability.getModuleName().get(),
+ capability.getRevision().or("")))
+ .build();
private final Capabilities capabilities;
private final ArrayListMultimap<String, Capability> capabilityMultiMap;
*/
package org.opendaylight.yanglib.impl;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Predicate;
import com.google.common.base.Strings;
import com.google.common.collect.Iterables;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
-import javax.annotation.Nullable;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
public YangLibProvider(final YanglibConfig yanglibConfig, final DataBroker dataBroker,
final SharedSchemaRepository schemaRepository) {
- this.yanglibConfig = Preconditions.checkNotNull(yanglibConfig);
- this.dataBroker = Preconditions.checkNotNull(dataBroker);
- this.schemaRepository = Preconditions.checkNotNull(schemaRepository);
+ this.yanglibConfig = requireNonNull(yanglibConfig);
+ this.dataBroker = requireNonNull(dataBroker);
+ this.schemaRepository = requireNonNull(schemaRepository);
}
@Override
}
final File cacheFolderFile = new File(yanglibConfig.getCacheFolder());
- Preconditions.checkArgument(cacheFolderFile.exists(), "cache-folder %s does not exist", cacheFolderFile);
- Preconditions.checkArgument(cacheFolderFile.isDirectory(), "cache-folder %s is not a directory",
- cacheFolderFile);
+ checkArgument(cacheFolderFile.exists(), "cache-folder %s does not exist", cacheFolderFile);
+ checkArgument(cacheFolderFile.isDirectory(), "cache-folder %s is not a directory", cacheFolderFile);
final FilesystemSchemaSourceCache<YangTextSchemaSource> cache =
new FilesystemSchemaSourceCache<>(schemaRepository, YangTextSchemaSource.class, cacheFolderFile);
tx.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(@Nullable final CommitInfo result) {
+ public void onSuccess(final CommitInfo result) {
LOG.debug("Modules state successfully populated with new modules");
}
tx.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(@Nullable final CommitInfo result) {
+ public void onSuccess(final CommitInfo result) {
LOG.debug("Modules state successfully updated.");
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netconf.sal.rest.impl;
import com.google.common.collect.ImmutableList;
import java.util.Locale;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicReference;
-import javax.annotation.Nonnull;
import javax.ws.rs.Consumes;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.ext.MessageBodyReader;
import javax.ws.rs.ext.Provider;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.netconf.sal.rest.api.Draft02;
import org.opendaylight.netconf.sal.rest.api.RestconfService;
import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
* @param resultCollection collection of parsed edits
* @throws IOException if operation fails
*/
- private void parseByName(@Nonnull final String name, @Nonnull final PatchEdit edit,
- @Nonnull final JsonReader in, @Nonnull final InstanceIdentifierContext<?> path,
- @Nonnull final StringModuleInstanceIdentifierCodec codec,
-
@Nonnull final List<PatchEntity> resultCollection,
- @Nonnull final AtomicReference<String> patchId) throws IOException {
+ private void parseByName(final @NonNull String name, final @NonNull PatchEdit edit,
+ final @NonNull JsonReader in, final @NonNull InstanceIdentifierContext<?> path,
+ final @NonNull StringModuleInstanceIdentifierCodec codec,
+
final @NonNull List<PatchEntity> resultCollection,
+ final @NonNull AtomicReference<String> patchId) throws IOException {
switch (name) {
case "edit" :
if (in.peek() == JsonToken.BEGIN_ARRAY) {
* @param codec StringModuleInstanceIdentifierCodec codec
* @throws IOException if operation fails
*/
- private void readEditDefinition(@Nonnull final PatchEdit edit, @Nonnull final JsonReader in,
- @Nonnull final InstanceIdentifierContext<?> path,
- @Nonnull final StringModuleInstanceIdentifierCodec codec) throws IOException {
+ private void readEditDefinition(final @NonNull PatchEdit edit, final @NonNull JsonReader in,
+ final @NonNull InstanceIdentifierContext<?> path,
+ final @NonNull StringModuleInstanceIdentifierCodec codec) throws IOException {
final StringBuffer value = new StringBuffer();
in.beginObject();
* @param in JsonReader reader
* @throws IOException if operation fails
*/
- private void readValueNode(@Nonnull final StringBuffer value, @Nonnull final JsonReader in) throws IOException {
+ private void readValueNode(final @NonNull StringBuffer value, final @NonNull JsonReader in) throws IOException {
in.beginObject();
value.append("{");
* @param in JsonReader reader
* @throws IOException if operation fails
*/
- private void readValueObject(@Nonnull final StringBuffer value, @Nonnull final JsonReader in) throws IOException {
+ private void readValueObject(final @NonNull StringBuffer value, final @NonNull JsonReader in) throws IOException {
// read simple leaf value
if (in.peek() == JsonToken.STRING) {
value.append("\"" + in.nextString() + "\"");
* @param in reader JsonReader reader
* @return NormalizedNode representing data
*/
- private static NormalizedNode<?, ?> readEditData(@Nonnull final JsonReader in,
- @Nonnull final SchemaNode targetSchemaNode, @Nonnull final InstanceIdentifierContext<?> path) {
+ private static NormalizedNode<?, ?> readEditData(final @NonNull JsonReader in,
+ final @NonNull SchemaNode targetSchemaNode, final @NonNull InstanceIdentifierContext<?> path) {
final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
JsonParserStream.create(writer,
* @param edit Instance of PatchEdit
* @return PatchEntity Patch entity
*/
- private static PatchEntity prepareEditOperation(@Nonnull final PatchEdit edit) {
+ private static PatchEntity prepareEditOperation(final @NonNull PatchEdit edit) {
if (edit.getOperation() != null && edit.getTargetSchemaNode() != null
&& checkDataPresence(edit.getOperation(), edit.getData() != null)) {
if (edit.getOperation().isWithValue()) {
* @return true if data is present when operation requires it or if there are no data when operation does not
* allow it, false otherwise
*/
- private static boolean checkDataPresence(@Nonnull final PatchEditOperation operation, final boolean hasData) {
+ private static boolean checkDataPresence(final @NonNull PatchEditOperation operation, final boolean hasData) {
return operation.isWithValue() == hasData;
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netconf.sal.rest.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.net.URI;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.util.AbstractModuleStringInstanceIdentifierCodec;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.model.api.Module;
private final String defaultPrefix;
public StringModuleInstanceIdentifierCodec(final SchemaContext context) {
- this.context = Preconditions.checkNotNull(context);
+ this.context = requireNonNull(context);
this.dataContextTree = DataSchemaContextTree.from(context);
this.defaultPrefix = "";
}
- StringModuleInstanceIdentifierCodec(final SchemaContext context, @Nonnull final String defaultPrefix) {
- this.context = Preconditions.checkNotNull(context);
+ StringModuleInstanceIdentifierCodec(final SchemaContext context, final @NonNull String defaultPrefix) {
+ this.context = requireNonNull(context);
this.dataContextTree = DataSchemaContextTree.from(context);
this.defaultPrefix = defaultPrefix;
}
@Override
- protected Module moduleForPrefix(@Nonnull final String prefix) {
+ protected Module moduleForPrefix(final String prefix) {
if (prefix.isEmpty() && !this.defaultPrefix.isEmpty()) {
return this.context.findModules(this.defaultPrefix).stream().findFirst().orElse(null);
} else {
}
}
- @Nonnull
@Override
protected DataSchemaContextTree getDataContextTree() {
return this.dataContextTree;
}
- @Nullable
@Override
- protected String prefixForNamespace(@Nonnull final URI namespace) {
+ protected String prefixForNamespace(final URI namespace) {
return this.context.findModules(namespace).stream().findFirst().map(Module::getName).orElse(null);
}
}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netconf.sal.rest.impl;
import com.google.common.base.Splitter;
import java.util.List;
import java.util.Locale;
import java.util.Optional;
-import javax.annotation.Nonnull;
import javax.ws.rs.Consumes;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.stream.XMLStreamException;
import javax.xml.transform.dom.DOMSource;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.netconf.sal.rest.api.Draft02;
import org.opendaylight.netconf.sal.rest.api.RestconfService;
import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
* @param operation Name of current operation
* @return List of value elements
*/
- private static List<Element> readValueNodes(@Nonnull final Element element,
- @Nonnull final PatchEditOperation operation) {
+ private static List<Element> readValueNodes(final @NonNull Element element,
+ final @NonNull PatchEditOperation operation) {
final Node valueNode = element.getElementsByTagName("value").item(0);
if (operation.isWithValue() && valueNode == null) {
* @param revision Module revision
* @return Non-conditional XPath
*/
- private static String prepareNonCondXpath(@Nonnull final DataSchemaNode schemaNode, @Nonnull final String target,
- @Nonnull final Element value, @Nonnull final String namespace, @Nonnull final String revision) {
+ private static String prepareNonCondXpath(final @NonNull DataSchemaNode schemaNode, final @NonNull String target,
+ final @NonNull Element value, final @NonNull String namespace, final @NonNull String revision) {
final Iterator<String> args = Splitter.on("/").split(target.substring(target.indexOf(':') + 1)).iterator();
final StringBuilder nonCondXpath = new StringBuilder();
* @param keys Iterator of list keys names
* @return Iterator of list keys values
*/
- private static Iterator<String> readKeyValues(@Nonnull final Element value, @Nonnull final Iterator<QName> keys) {
+ private static Iterator<String> readKeyValues(final @NonNull Element value, final @NonNull Iterator<QName> keys) {
final List<String> result = new ArrayList<>();
while (keys.hasNext()) {
* @param keyNames Iterator of list keys names
* @param keyValues Iterator of list keys values
*/
- private static void appendKeys(@Nonnull final StringBuilder nonCondXpath, @Nonnull final Iterator<QName> keyNames,
- @Nonnull final Iterator<String> keyValues) {
+ private static void appendKeys(final @NonNull StringBuilder nonCondXpath, final @NonNull Iterator<QName> keyNames,
+ final @NonNull Iterator<String> keyValues) {
while (keyNames.hasNext()) {
- nonCondXpath.append("[");
- nonCondXpath.append(keyNames.next().getLocalName());
- nonCondXpath.append("=");
- nonCondXpath.append("'");
- nonCondXpath.append(keyValues.next());
- nonCondXpath.append("'");
- nonCondXpath.append("]");
+ nonCondXpath.append("[").append(keyNames.next().getLocalName()).append("='").append(keyValues.next())
+ .append("']");
}
}
}
package org.opendaylight.netconf.sal.restconf.api;
import com.google.common.base.Optional;
-import javax.annotation.Nonnull;
import javax.ws.rs.core.MultivaluedMap;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.common.OperationFailedException;
* @param payload the payload data in JSON format.
* @throws OperationFailedException if the request fails.
*/
- void put(String uriPath, @Nonnull String payload) throws OperationFailedException;
+ void put(String uriPath, @NonNull String payload) throws OperationFailedException;
/**
* Issues a restconf POST request to the configuration data store.
* @param payload the payload data in JSON format.
* @throws OperationFailedException if the request fails.
*/
- void post(String uriPath, @Nonnull String payload) throws OperationFailedException;
+ void post(String uriPath, @NonNull String payload) throws OperationFailedException;
/**
* Issues a restconf DELETE request to the configuration data store.
* @return an Optional containing the output in JSON format if the RPC returns output.
* @throws OperationFailedException if the request fails.
*/
- Optional<String> invokeRpc(@Nonnull String uriPath, Optional<String> input) throws OperationFailedException;
+ Optional<String> invokeRpc(@NonNull String uriPath, Optional<String> input) throws OperationFailedException;
/**
* Issues a restconf PATCH request to the configuration data store.
* @return an Optional containing the patch response data in JSON format.
* @throws OperationFailedException if the request fails.
*/
- Optional<String> patch(@Nonnull String uriPath, @Nonnull String payload) throws OperationFailedException;
+ Optional<String> patch(@NonNull String uriPath, @NonNull String payload) throws OperationFailedException;
/**
* Subscribe to a stream.
* @return On optional containing the JSON response.
* @throws OperationFailedException if the requests fails.
*/
- Optional<String> subscribeToStream(@Nonnull String identifier, MultivaluedMap<String, String> params)
+ Optional<String> subscribeToStream(@NonNull String identifier, MultivaluedMap<String, String> params)
throws OperationFailedException;
}
package org.opendaylight.netconf.sal.restconf.impl;
import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.SettableFuture;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Map.Entry;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
-import javax.annotation.Nonnull;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
final BatchedExistenceCheck ret = new BatchedExistenceCheck(children.size());
for (NormalizedNode<?, ?> child : children) {
final YangInstanceIdentifier path = parentPath.node(child.getIdentifier());
- final ListenableFuture<Boolean> f = readTx.exists(datastore, path);
- Futures.addCallback(f, new FutureCallback<Boolean>() {
+ readTx.exists(datastore, path).addCallback(new FutureCallback<Boolean>() {
@Override
- public void onSuccess(@Nonnull final Boolean result) {
+ public void onSuccess(final Boolean result) {
ret.complete(path, result);
}
*/
package org.opendaylight.netconf.sal.restconf.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.lang.annotation.Annotation;
import java.nio.charset.StandardCharsets;
import java.util.List;
-import javax.annotation.Nonnull;
import javax.inject.Inject;
import javax.inject.Singleton;
import javax.ws.rs.core.MediaType;
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
public void put(final String uriPath, final String payload) throws OperationFailedException {
- Preconditions.checkNotNull(payload, "payload can't be null");
+ requireNonNull(payload, "payload can't be null");
LOG.debug("put: uriPath: {}, payload: {}", uriPath, payload);
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- public void post(final String uriPath, final String payload)
- throws OperationFailedException {
- Preconditions.checkNotNull(payload, "payload can't be null");
+ public void post(final String uriPath, final String payload) throws OperationFailedException {
+ requireNonNull(payload, "payload can't be null");
LOG.debug("post: uriPath: {}, payload: {}", uriPath, payload);
@Override
public Optional<String> invokeRpc(final String uriPath, final Optional<String> input)
throws OperationFailedException {
- Preconditions.checkNotNull(uriPath, "uriPath can't be null");
+ requireNonNull(uriPath, "uriPath can't be null");
final String actualInput = input.isPresent() ? input.get() : null;
throws OperationFailedException {
String output = null;
- Preconditions.checkNotNull(payload, "payload can't be null");
+ requireNonNull(payload, "payload can't be null");
LOG.debug("patch: uriPath: {}, payload: {}", uriPath, payload);
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- public Optional<String> subscribeToStream(@Nonnull final String identifier,
- final MultivaluedMap<String, String> params) throws OperationFailedException {
+ public Optional<String> subscribeToStream(final String identifier, final MultivaluedMap<String, String> params)
+ throws OperationFailedException {
//Note: We use http://127.0.0.1 because the Uri parser requires something there though it does nothing
String uri = new StringBuilder("http://127.0.0.1:8081/restconf/streams/stream/").append(identifier).toString();
MultivaluedMap queryParams = params != null ? params : new MultivaluedHashMap<String, String>();
return Optional.fromNullable(jsonRes);
}
- private String toJson(final PatchStatusContext patchStatusContext) throws IOException {
+ private static String toJson(final PatchStatusContext patchStatusContext) throws IOException {
final PatchJsonBodyWriter writer = new PatchJsonBodyWriter();
final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
writer.writeTo(patchStatusContext, PatchStatusContext.class, null, EMPTY_ANNOTATIONS,
*/
package org.opendaylight.netconf.sal.streams.listeners;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import java.io.IOException;
import java.time.Instant;
import java.util.Collection;
import java.util.Map;
import java.util.Map.Entry;
-import javax.annotation.Nonnull;
import javax.xml.stream.XMLStreamException;
import javax.xml.transform.dom.DOMResult;
import org.json.XML;
ListenerAdapter(final YangInstanceIdentifier path, final String streamName,
final NotificationOutputType outputType, final ControllerContext controllerContext) {
register(this);
- this.outputType = Preconditions.checkNotNull(outputType);
- this.path = Preconditions.checkNotNull(path);
- Preconditions.checkArgument(streamName != null && !streamName.isEmpty());
+ this.outputType = requireNonNull(outputType);
+ this.path = requireNonNull(path);
+ checkArgument(streamName != null && !streamName.isEmpty());
this.streamName = streamName;
this.controllerContext = controllerContext;
}
@Override
- public void onDataTreeChanged(@Nonnull final Collection<DataTreeCandidate> dataTreeCandidates) {
+ public void onDataTreeChanged(final Collection<DataTreeCandidate> dataTreeCandidates) {
final Instant now = Instant.now();
if (!checkStartStop(now, this)) {
return;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.restconf.nb.rfc8040.codecs;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.net.URI;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.util.AbstractModuleStringInstanceIdentifierCodec;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.model.api.Module;
private final String defaultPrefix;
public StringModuleInstanceIdentifierCodec(final SchemaContext context) {
- this.context = Preconditions.checkNotNull(context);
+ this.context = requireNonNull(context);
this.dataContextTree = DataSchemaContextTree.from(context);
this.defaultPrefix = "";
}
- public StringModuleInstanceIdentifierCodec(final SchemaContext context, @Nonnull final String defaultPrefix) {
- this.context = Preconditions.checkNotNull(context);
+ public StringModuleInstanceIdentifierCodec(final SchemaContext context, final @NonNull String defaultPrefix) {
+ this.context = requireNonNull(context);
this.dataContextTree = DataSchemaContextTree.from(context);
this.defaultPrefix = defaultPrefix;
}
@Override
- protected Module moduleForPrefix(@Nonnull final String prefix) {
+ protected Module moduleForPrefix(final String prefix) {
final String moduleName = prefix.isEmpty() && !defaultPrefix.isEmpty() ? defaultPrefix : prefix;
return context.findModules(moduleName).stream().findFirst().orElse(null);
}
- @Nonnull
@Override
public DataSchemaContextTree getDataContextTree() {
return this.dataContextTree;
}
- @Nullable
@Override
- protected String prefixForNamespace(@Nonnull final URI namespace) {
+ protected String prefixForNamespace(final URI namespace) {
return this.context.findModules(namespace).stream().findFirst().map(Module::getName).orElse(null);
}
}
*/
package org.opendaylight.restconf.nb.rfc8040.jersey.providers.patch;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonToken;
import java.util.Locale;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicReference;
-import javax.annotation.Nonnull;
import javax.ws.rs.Consumes;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.ext.Provider;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.common.errors.RestconfError.ErrorTag;
* @param resultCollection collection of parsed edits
* @throws IOException if operation fails
*/
- private void parseByName(@Nonnull final String name, @Nonnull final PatchEdit edit,
- @Nonnull final JsonReader in, @Nonnull final InstanceIdentifierContext<?> path,
- @Nonnull final StringModuleInstanceIdentifierCodec codec,
-
@Nonnull final List<PatchEntity> resultCollection,
- @Nonnull final AtomicReference<String> patchId) throws IOException {
+ private void parseByName(final @NonNull String name, final @NonNull PatchEdit edit,
+ final @NonNull JsonReader in, final @NonNull InstanceIdentifierContext<?> path,
+ final @NonNull StringModuleInstanceIdentifierCodec codec,
+
final @NonNull List<PatchEntity> resultCollection,
+ final @NonNull AtomicReference<String> patchId) throws IOException {
switch (name) {
case "edit":
if (in.peek() == JsonToken.BEGIN_ARRAY) {
* @param codec Draft11StringModuleInstanceIdentifierCodec codec
* @throws IOException if operation fails
*/
- private void readEditDefinition(@Nonnull final PatchEdit edit, @Nonnull final JsonReader in,
- @Nonnull final InstanceIdentifierContext<?> path,
- @Nonnull final StringModuleInstanceIdentifierCodec codec) throws IOException {
+ private void readEditDefinition(final @NonNull PatchEdit edit, final @NonNull JsonReader in,
+ final @NonNull InstanceIdentifierContext<?> path,
+ final @NonNull StringModuleInstanceIdentifierCodec codec) throws IOException {
String deferredValue = null;
in.beginObject();
break;
case "value":
- Preconditions.checkArgument(edit.getData() == null && deferredValue == null,
- "Multiple value entries found");
+ checkArgument(edit.getData() == null && deferredValue == null, "Multiple value entries found");
if (edit.getTargetSchemaNode() == null) {
final StringBuilder sb = new StringBuilder();
* @param in JsonReader reader
* @throws IOException if operation fails
*/
- private void readValueNode(@Nonnull final StringBuilder sb, @Nonnull final JsonReader in) throws IOException {
+ private void readValueNode(final @NonNull StringBuilder sb, final @NonNull JsonReader in) throws IOException {
in.beginObject();
sb.append("{\"").append(in.nextName()).append("\":");
* @param in JsonReader reader
* @throws IOException if operation fails
*/
- private void readValueObject(@Nonnull final StringBuilder sb, @Nonnull final JsonReader in) throws IOException {
+ private void readValueObject(final @NonNull StringBuilder sb, final @NonNull JsonReader in) throws IOException {
// read simple leaf value
if (in.peek() == JsonToken.STRING) {
sb.append('"').append(in.nextString()).append('"');
* @param in reader JsonReader reader
* @return NormalizedNode representing data
*/
- private static NormalizedNode<?, ?> readEditData(@Nonnull final JsonReader in,
- @Nonnull final SchemaNode targetSchemaNode, @Nonnull final InstanceIdentifierContext<?> path) {
+ private static NormalizedNode<?, ?> readEditData(final @NonNull JsonReader in,
+ final @NonNull SchemaNode targetSchemaNode, final @NonNull InstanceIdentifierContext<?> path) {
final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
JsonParserStream.create(writer, JSONCodecFactorySupplier.RFC7951.getShared(path.getSchemaContext()),
* @param edit Instance of PatchEdit
* @return PatchEntity Patch entity
*/
- private static PatchEntity prepareEditOperation(@Nonnull final PatchEdit edit) {
+ private static PatchEntity prepareEditOperation(final @NonNull PatchEdit edit) {
if (edit.getOperation() != null && edit.getTargetSchemaNode() != null
&& checkDataPresence(edit.getOperation(), edit.getData() != null)) {
if (!edit.getOperation().isWithValue()) {
* @return true if data is present when operation requires it or if there are no data when operation does not
* allow it, false otherwise
*/
- private static boolean checkDataPresence(@Nonnull final PatchEditOperation operation, final boolean hasData) {
+ private static boolean checkDataPresence(final @NonNull PatchEditOperation operation, final boolean hasData) {
return operation.isWithValue() == hasData;
}
}
void setId(final String id) {
- this.id = Preconditions.checkNotNull(id);
+ this.id = requireNonNull(id);
}
PatchEditOperation getOperation() {
}
void setOperation(final PatchEditOperation operation) {
- this.operation = Preconditions.checkNotNull(operation);
+ this.operation = requireNonNull(operation);
}
YangInstanceIdentifier getTarget() {
}
void setTarget(final YangInstanceIdentifier target) {
- this.target = Preconditions.checkNotNull(target);
+ this.target = requireNonNull(target);
}
SchemaNode getTargetSchemaNode() {
}
void setTargetSchemaNode(final SchemaNode targetSchemaNode) {
- this.targetSchemaNode = Preconditions.checkNotNull(targetSchemaNode);
+ this.targetSchemaNode = requireNonNull(targetSchemaNode);
}
NormalizedNode<?, ?> getData() {
}
void setData(final NormalizedNode<?, ?> data) {
- this.data = Preconditions.checkNotNull(data);
+ this.data = requireNonNull(data);
}
void clear() {
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.restconf.nb.rfc8040.jersey.providers.patch;
import com.google.common.base.Splitter;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
-import javax.annotation.Nonnull;
import javax.ws.rs.Consumes;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.ext.Provider;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.stream.XMLStreamException;
import javax.xml.transform.dom.DOMSource;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.common.errors.RestconfError.ErrorTag;
* @param operation Name of current operation
* @return List of value elements
*/
- private static List<Element> readValueNodes(@Nonnull final Element element,
- @Nonnull final PatchEditOperation operation) {
+ private static List<Element> readValueNodes(final @NonNull Element element,
+ final @NonNull PatchEditOperation operation) {
final Node valueNode = element.getElementsByTagName("value").item(0);
if (operation.isWithValue() && valueNode == null) {
* @param revision Module revision
* @return Non-conditional XPath
*/
- private static String prepareNonCondXpath(@Nonnull final DataSchemaNode schemaNode, @Nonnull final String target,
- @Nonnull final Element value, @Nonnull final String namespace, @Nonnull final String revision) {
+ private static String prepareNonCondXpath(final @NonNull DataSchemaNode schemaNode, final @NonNull String target,
+ final @NonNull Element value, final @NonNull String namespace, final @NonNull String revision) {
final Iterator<String> args = SLASH_SPLITTER.split(target.substring(target.indexOf(':') + 1)).iterator();
final StringBuilder nonCondXpath = new StringBuilder();
* @param keys Iterator of list keys names
* @return Iterator of list keys values
*/
- private static Iterator<String> readKeyValues(@Nonnull final Element value, @Nonnull final Iterator<QName> keys) {
+ private static Iterator<String> readKeyValues(final @NonNull Element value, final @NonNull Iterator<QName> keys) {
final List<String> result = new ArrayList<>();
while (keys.hasNext()) {
* @param keyNames Iterator of list keys names
* @param keyValues Iterator of list keys values
*/
- private static void appendKeys(@Nonnull final StringBuilder nonCondXpath, @Nonnull final Iterator<QName> keyNames,
- @Nonnull final Iterator<String> keyValues) {
+ private static void appendKeys(final @NonNull StringBuilder nonCondXpath, final @NonNull Iterator<QName> keyNames,
+ final @NonNull Iterator<String> keyValues) {
while (keyNames.hasNext()) {
- nonCondXpath.append('[');
- nonCondXpath.append(keyNames.next().getLocalName());
- nonCondXpath.append("='");
- nonCondXpath.append(keyValues.next());
- nonCondXpath.append("']");
+ nonCondXpath.append('[').append(keyNames.next().getLocalName()).append("='").append(keyValues.next())
+ .append("']");
}
}
}
package org.opendaylight.restconf.nb.rfc8040.rests.services.api;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.common.OperationFailedException;
* @param payload the payload data in JSON format.
* @throws OperationFailedException if the request fails.
*/
- void put(String uriPath, @Nonnull String payload) throws OperationFailedException;
+ void put(String uriPath, @NonNull String payload) throws OperationFailedException;
/**
* Issues a restconf POST request to the configuration data store.
* @param payload the payload data in JSON format.
* @throws OperationFailedException if the request fails.
*/
- void post(String uriPath, @Nonnull String payload) throws OperationFailedException;
+ void post(String uriPath, @NonNull String payload) throws OperationFailedException;
/**
* Issues a restconf DELETE request to the configuration data store.
* @return an Optional containing the output in JSON format if the RPC returns output.
* @throws OperationFailedException if the request fails.
*/
- Optional<String> invokeRpc(@Nonnull String uriPath, Optional<String> input) throws OperationFailedException;
+ Optional<String> invokeRpc(@NonNull String uriPath, Optional<String> input) throws OperationFailedException;
/**
* Issues a restconf PATCH request to the configuration data store.
* @return an Optional containing the patch response data in JSON format.
* @throws OperationFailedException if the request fails.
*/
- Optional<String> patch(@Nonnull String uriPath, @Nonnull String payload) throws OperationFailedException;
+ Optional<String> patch(@NonNull String uriPath, @NonNull String payload) throws OperationFailedException;
}
*/
package org.opendaylight.restconf.nb.rfc8040.rests.services.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Optional;
-import javax.annotation.Nullable;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.core.Response;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.context.NormalizedNodeContext;
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
public void put(final String uriPath, final String payload) throws OperationFailedException {
- Preconditions.checkNotNull(payload, "payload can't be null");
+ requireNonNull(payload, "payload can't be null");
LOG.debug("put: uriPath: {}, payload: {}", uriPath, payload);
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- public void post(final String uriPath, final String payload)
- throws OperationFailedException {
- Preconditions.checkNotNull(payload, "payload can't be null");
+ public void post(final String uriPath, final String payload) throws OperationFailedException {
+ requireNonNull(payload, "payload can't be null");
LOG.debug("post: uriPath: {}, payload: {}", uriPath, payload);
@Override
public Optional<String> invokeRpc(final String uriPath, final Optional<String> input)
throws OperationFailedException {
- Preconditions.checkNotNull(uriPath, "uriPath can't be null");
+ requireNonNull(uriPath, "uriPath can't be null");
final String actualInput = input.isPresent() ? input.get() : null;
throws OperationFailedException {
String output = null;
- Preconditions.checkNotNull(payload, "payload can't be null");
+ requireNonNull(payload, "payload can't be null");
LOG.debug("patch: uriPath: {}, payload: {}", uriPath, payload);
public void close() {
}
- private NormalizedNodeContext toNormalizedNodeContext(final String uriPath, @Nullable final String payload,
+ private NormalizedNodeContext toNormalizedNodeContext(final String uriPath, final @Nullable String payload,
final boolean isPost) throws OperationFailedException {
final InstanceIdentifierContext<?> instanceIdentifierContext = ParserIdentifier.toInstanceIdentifier(
uriPath, schemaContextHandler.get(), Optional.of(mountPointServiceHandler.get()));
*/
package org.opendaylight.restconf.nb.rfc8040.rests.services.impl;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.restconf.nb.rfc8040.rests.utils.RestconfStreamsConstants.CREATE_NOTIFICATION_STREAM;
import static org.opendaylight.restconf.nb.rfc8040.rests.utils.RestconfStreamsConstants.STREAM_ACCESS_PATH_PART;
import static org.opendaylight.restconf.nb.rfc8040.rests.utils.RestconfStreamsConstants.STREAM_LOCATION_PATH_PART;
import static org.opendaylight.restconf.nb.rfc8040.rests.utils.RestconfStreamsConstants.STREAM_PATH;
-import com.google.common.base.Preconditions;
import java.time.Clock;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Map.Entry;
import java.util.Objects;
import java.util.Optional;
-import javax.annotation.Nonnull;
import javax.ws.rs.Path;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.UriInfo;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMMountPoint;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
@Override
public Response putData(final String identifier, final NormalizedNodeContext payload, final UriInfo uriInfo) {
- Preconditions.checkNotNull(payload);
+ requireNonNull(payload);
boolean insertUsed = false;
boolean pointUsed = false;
@Override
public Response postData(final NormalizedNodeContext payload, final UriInfo uriInfo) {
- Preconditions.checkNotNull(payload);
+ requireNonNull(payload);
boolean insertUsed = false;
boolean pointUsed = false;
@Override
public PatchStatusContext patchData(final PatchContext context, final UriInfo uriInfo) {
- Preconditions.checkNotNull(context);
- final DOMMountPoint mountPoint = context.getInstanceIdentifierContext().getMountPoint();
+ final DOMMountPoint mountPoint = requireNonNull(context).getInstanceIdentifierContext().getMountPoint();
final TransactionChainHandler localTransactionChainHandler;
final SchemaContextRef ref;
* mount point reference
* @return {@link TransactionChainHandler}
*/
- private static TransactionChainHandler transactionChainOfMountPoint(@Nonnull final DOMMountPoint mountPoint) {
+ private static TransactionChainHandler transactionChainOfMountPoint(final @NonNull DOMMountPoint mountPoint) {
final Optional<DOMDataBroker> domDataBrokerService = mountPoint.getService(DOMDataBroker.class);
if (domDataBrokerService.isPresent()) {
return new TransactionChainHandler(domDataBrokerService.get());
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
-import javax.annotation.Nonnull;
import javax.ws.rs.Path;
import javax.ws.rs.core.UriInfo;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMNotificationService;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
*
* @return start-time
*/
- @Nonnull
- public Instant getStart() {
+ public @NonNull Instant getStart() {
return start;
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.restconf.nb.rfc8040.rests.utils;
import com.google.common.collect.Sets;
import java.util.List;
import java.util.Set;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.common.errors.RestconfError;
import org.opendaylight.restconf.common.errors.RestconfError.ErrorTag;
* @param allowedParameters
* allowed parameters for operation
*/
- static void checkParametersTypes(@Nonnull final String operationType,
- @Nonnull final Set<String> usedParameters,
- @Nonnull final String... allowedParameters) {
+ static void checkParametersTypes(final @NonNull String operationType,
+ final @NonNull Set<String> usedParameters,
+ final @NonNull String... allowedParameters) {
final Set<String> notAllowedParameters = Sets.newHashSet(usedParameters);
notAllowedParameters.removeAll(Sets.newHashSet(allowedParameters));
* @param parameterName
* URI parameter name
*/
- static void checkParameterCount(@Nonnull final List<String> parameterValues, @Nonnull final String parameterName) {
+ static void checkParameterCount(final @NonNull List<String> parameterValues, final @NonNull String parameterName) {
if (parameterValues.size() > 1) {
throw new RestconfDocumentedException(
"Parameter " + parameterName + " can appear at most once in request URI",
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Collectors;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
import javax.ws.rs.core.UriInfo;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
* set tagged for {@link WriterParameters}
* @return {@link WriterParameters}
*/
- @Nonnull
- public static WriterParameters parseUriParameters(@Nonnull final InstanceIdentifierContext<?> identifier,
- @Nullable final UriInfo uriInfo, final boolean tagged) {
+ public static @NonNull WriterParameters parseUriParameters(final @NonNull InstanceIdentifierContext<?> identifier,
+ final @Nullable UriInfo uriInfo, final boolean tagged) {
return parseParams(identifier, uriInfo, tagged);
}
* URI info
* @return {@link WriterParameters}
*/
- @Nonnull
- public static WriterParameters parseUriParameters(@Nonnull final InstanceIdentifierContext<?> identifier,
- @Nullable final UriInfo uriInfo) {
+ public static @NonNull WriterParameters parseUriParameters(final @NonNull InstanceIdentifierContext<?> identifier,
+ final @Nullable UriInfo uriInfo) {
return parseParams(identifier, uriInfo, false);
}
* schema context
* @return {@link NormalizedNode}
*/
- @Nullable
- public static NormalizedNode<?, ?> readData(@Nonnull final String valueOfContent,
- @Nonnull final TransactionVarsWrapper transactionNode, final SchemaContext schemaContext) {
+ public static @Nullable NormalizedNode<?, ?> readData(final @NonNull String valueOfContent,
+ final @NonNull TransactionVarsWrapper transactionNode, final SchemaContext schemaContext) {
return readData(valueOfContent, transactionNode, null, schemaContext);
}
* schema context
* @return {@link NormalizedNode}
*/
- @Nullable
- public static NormalizedNode<?, ?> readData(@Nonnull final String valueOfContent,
- @Nonnull final TransactionVarsWrapper transactionNode, final String withDefa, final SchemaContext ctx) {
+ public static @Nullable NormalizedNode<?, ?> readData(final @NonNull String valueOfContent,
+ final @NonNull TransactionVarsWrapper transactionNode, final String withDefa, final SchemaContext ctx) {
switch (valueOfContent) {
case RestconfDataServiceConstant.ReadData.CONFIG:
transactionNode.setLogicalDatastoreType(LogicalDatastoreType.CONFIGURATION);
* {@link TransactionVarsWrapper} - wrapper for variables
* @return {@link NormalizedNode}
*/
- @Nullable
- private static NormalizedNode<?, ?> readDataViaTransaction(
- @Nonnull final TransactionVarsWrapper transactionNode) {
+ private static @Nullable NormalizedNode<?, ?> readDataViaTransaction(
+ final @NonNull TransactionVarsWrapper transactionNode) {
final NormalizedNodeFactory dataFactory = new NormalizedNodeFactory();
try (DOMDataTreeReadTransaction tx = transactionNode.getTransactionChain().newReadOnlyTransaction()) {
final FluentFuture<Optional<NormalizedNode<?, ?>>> listenableFuture = tx.read(
* schema context
* @return {@link NormalizedNode}
*/
- @Nullable
- private static NormalizedNode<?, ?> readAllData(@Nonnull final TransactionVarsWrapper transactionNode,
+ private static @Nullable NormalizedNode<?, ?> readAllData(final @NonNull TransactionVarsWrapper transactionNode,
final String withDefa, final SchemaContext ctx) {
// PREPARE STATE DATA NODE
transactionNode.setLogicalDatastoreType(LogicalDatastoreType.OPERATIONAL);
* data node of config data
* @return {@link NormalizedNode}
*/
- @Nonnull
- private static NormalizedNode<?, ?> mergeStateAndConfigData(@Nonnull final NormalizedNode<?, ?> stateDataNode,
- @Nonnull final NormalizedNode<?, ?> configDataNode) {
+ private static @NonNull NormalizedNode<?, ?> mergeStateAndConfigData(
+ final @NonNull NormalizedNode<?, ?> stateDataNode, final @NonNull NormalizedNode<?, ?> configDataNode) {
validateNodeMerge(stateDataNode, configDataNode);
if (configDataNode instanceof RpcDefinition) {
return prepareRpcData(configDataNode, stateDataNode);
* @param configDataNode
* data node of config data
*/
- private static void validateNodeMerge(@Nonnull final NormalizedNode<?, ?> stateDataNode,
- @Nonnull final NormalizedNode<?, ?> configDataNode) {
+ private static void validateNodeMerge(final @NonNull NormalizedNode<?, ?> stateDataNode,
+ final @NonNull NormalizedNode<?, ?> configDataNode) {
final QNameModule moduleOfStateData = stateDataNode.getIdentifier().getNodeType().getModule();
final QNameModule moduleOfConfigData = configDataNode.getIdentifier().getNodeType().getModule();
if (!moduleOfStateData.equals(moduleOfConfigData)) {
* data node of state data
* @return {@link NormalizedNode}
*/
- @Nonnull
- private static NormalizedNode<?, ?> prepareRpcData(@Nonnull final NormalizedNode<?, ?> configDataNode,
- @Nonnull final NormalizedNode<?, ?> stateDataNode) {
+ private static @NonNull NormalizedNode<?, ?> prepareRpcData(final @NonNull NormalizedNode<?, ?> configDataNode,
+ final @NonNull NormalizedNode<?, ?> stateDataNode) {
final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder = ImmutableNodes
.mapEntryBuilder();
mapEntryBuilder.withNodeIdentifier((NodeIdentifierWithPredicates) configDataNode.getIdentifier());
* @param mapEntryBuilder
* builder for mapping data
*/
- private static void mapRpcDataNode(@Nonnull final NormalizedNode<?, ?> dataNode,
- @Nonnull final DataContainerNodeBuilder<
- NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder) {
+ private static void mapRpcDataNode(final @NonNull NormalizedNode<?, ?> dataNode,
+ final @NonNull DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder) {
((ContainerNode) dataNode).getValue().forEach(mapEntryBuilder::addChild);
}
* @return {@link NormalizedNode}
*/
@SuppressWarnings("unchecked")
- @Nonnull
- private static NormalizedNode<?, ?> prepareData(@Nonnull final NormalizedNode<?, ?> configDataNode,
- @Nonnull final NormalizedNode<?, ?> stateDataNode) {
+ private static @NonNull NormalizedNode<?, ?> prepareData(final @NonNull NormalizedNode<?, ?> configDataNode,
+ final @NonNull NormalizedNode<?, ?> stateDataNode) {
if (configDataNode instanceof OrderedMapNode) {
final CollectionNodeBuilder<MapEntryNode, OrderedMapNode> builder = Builders
.orderedMapBuilder().withNodeIdentifier(((MapNode) configDataNode).getIdentifier());
* builder
*/
private static <T extends NormalizedNode<? extends PathArgument, ?>> void mapValueToBuilder(
- @Nonnull final Collection<T> configData,
- @Nonnull final Collection<T> stateData,
- @Nonnull final NormalizedNodeContainerBuilder<?, PathArgument, T, ?> builder) {
+ final @NonNull Collection<T> configData, final @NonNull Collection<T> stateData,
+ final @NonNull NormalizedNodeContainerBuilder<?, PathArgument, T, ?> builder) {
final Map<PathArgument, T> configMap = configData.stream().collect(
Collectors.toMap(NormalizedNode::getIdentifier, Function.identity()));
final Map<PathArgument, T> stateMap = stateData.stream().collect(
* - builder
*/
private static <T extends NormalizedNode<? extends PathArgument, ?>> void mapDataToBuilder(
- @Nonnull final Map<PathArgument, T> configMap,
- @Nonnull final Map<PathArgument, T> stateMap,
- @Nonnull final NormalizedNodeContainerBuilder<?, PathArgument, T, ?> builder) {
+ final @NonNull Map<PathArgument, T> configMap, final @NonNull Map<PathArgument, T> stateMap,
+ final @NonNull NormalizedNodeContainerBuilder<?, PathArgument, T, ?> builder) {
configMap.entrySet().stream().filter(x -> !stateMap.containsKey(x.getKey())).forEach(
y -> builder.addChild(y.getValue()));
stateMap.entrySet().stream().filter(x -> !configMap.containsKey(x.getKey())).forEach(
*/
@SuppressWarnings("unchecked")
private static <T extends NormalizedNode<? extends PathArgument, ?>> void mergeDataToBuilder(
- @Nonnull final Map<PathArgument, T> configMap,
- @Nonnull final Map<PathArgument, T> stateMap,
- @Nonnull final NormalizedNodeContainerBuilder<?, PathArgument, T, ?> builder) {
+ final @NonNull Map<PathArgument, T> configMap, final @NonNull Map<PathArgument, T> stateMap,
+ final @NonNull NormalizedNodeContainerBuilder<?, PathArgument, T, ?> builder) {
// it is enough to process only config data because operational contains the same data
configMap.entrySet().stream().filter(x -> stateMap.containsKey(x.getKey())).forEach(
y -> builder.addChild((T) prepareData(y.getValue(), stateMap.get(y.getKey()))));
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.restconf.nb.rfc8040.utils.parser;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.common.errors.RestconfError.ErrorTag;
* @param input input value of fields parameter
* @return {@link List}
*/
- @Nonnull
- public static List<Set<QName>> parseFieldsParameter(@Nonnull final InstanceIdentifierContext<?> identifier,
- @Nonnull final String input) {
+ public static @NonNull List<Set<QName>> parseFieldsParameter(final @NonNull InstanceIdentifierContext<?> identifier,
+ final @NonNull String input) {
final List<Set<QName>> parsed = new ArrayList<>();
final SchemaContext context = identifier.getSchemaContext();
final QNameModule startQNameModule = identifier.getSchemaNode().getQName().getModule();
* @param parsed list of results
* @param context schema context
*/
- private static void parseInput(@Nonnull final String input,
- @Nonnull final QNameModule startQNameModule,
- @Nonnull final DataSchemaContextNode<?> startNode,
- @Nonnull final List<Set<QName>> parsed,
- @Nonnull final SchemaContext context) {
+ private static void parseInput(final @NonNull String input, final @NonNull QNameModule startQNameModule,
+ final @NonNull DataSchemaContextNode<?> startNode,
+ final @NonNull List<Set<QName>> parsed, final SchemaContext context) {
int currentPosition = 0;
int startPosition = 0;
DataSchemaContextNode<?> currentNode = startNode;
* @param level current nodes level
* @return {@link DataSchemaContextNode}
*/
- @Nonnull
- private static DataSchemaContextNode<?> addChildToResult(
- @Nonnull final DataSchemaContextNode<?> currentNode,
- @Nonnull final String identifier,
- @Nonnull final QNameModule currentQNameModule,
- @Nonnull final Set<QName> level) {
+ private static @NonNull DataSchemaContextNode<?> addChildToResult(
+ final @NonNull DataSchemaContextNode<?> currentNode, final @NonNull String identifier,
+ final @NonNull QNameModule currentQNameModule, final @NonNull Set<QName> level) {
final QName childQName = QName.create(currentQNameModule, identifier);
// resolve parent node
* @param qualifiedName qname of initial node
* @return {@link DataSchemaContextNode}
*/
- @Nullable
- private static DataSchemaContextNode<?> resolveMixinNode(@Nullable final DataSchemaContextNode<?> node,
- @Nonnull final Set<QName> level,
- @Nonnull final QName qualifiedName) {
+ private static @Nullable DataSchemaContextNode<?> resolveMixinNode(final @Nullable DataSchemaContextNode<?> node,
+ final @NonNull Set<QName> level, final @NonNull QName qualifiedName) {
DataSchemaContextNode<?> currentNode = node;
while (currentNode != null && currentNode.isMixin()) {
level.add(qualifiedName);
* @param input input where to find for closing parenthesis
* @return int position of closing parenthesis increased by one
*/
- private static int findClosingParenthesis(@Nonnull final String input) {
+ private static int findClosingParenthesis(final @Nullable String input) {
int position = 0;
int count = 1;
Code Review / netconf.git / commitdiff