import static com.google.common.util.concurrent.Futures.immediateFuture;
-import com.google.common.base.Function;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Throwables;
import java.util.Set;
import java.util.concurrent.Future;
import java.util.regex.Pattern;
-import javax.annotation.Nullable;
import javax.xml.stream.XMLStreamException;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.dom.DOMSource;
final List<Stream> availableStreams;
try {
availableStreams = mount.getAvailableStreams();
- streamMap = Maps.uniqueIndex(availableStreams, new Function<Stream, String>() {
- @Nullable
- @Override
- public String apply(@Nullable Stream input) {
- return input.getName().getValue();
- }
- });
+ streamMap = Maps.uniqueIndex(availableStreams, input -> input.getName().getValue());
} catch (ReadFailedException e) {
LOG.warn("Can not read streams for node {}", mount.getNodeId());
}
}
@Override
- public Future<RpcResult<Void>> disJoinTopic(DisJoinTopicInput input) {
+ public Future<RpcResult<Void>> disJoinTopic(final DisJoinTopicInput input) {
for (NotificationTopicRegistration reg : notificationTopicRegistrations.values()) {
reg.unRegisterNotificationTopic(input.getTopicId());
}
}
}
- private void publishNotification(final DOMNotification notification, TopicId topicId) {
+ private void publishNotification(final DOMNotification notification, final TopicId topicId) {
final ContainerNode topicNotification = Builders.containerBuilder().withNodeIdentifier(TOPIC_NOTIFICATION_ARG)
.withChild(ImmutableNodes.leafNode(TOPIC_ID_ARG, topicId))
.withChild(ImmutableNodes.leafNode(EVENT_SOURCE_ARG, mount.getNodeId()))
* @param notificationPattern pattern
* @return notification paths
*/
- private List<SchemaPath> getMatchingNotifications(NotificationPattern notificationPattern) {
+ private List<SchemaPath> getMatchingNotifications(final NotificationPattern notificationPattern) {
final String regex = notificationPattern.getValue();
final Pattern pattern = Pattern.compile(regex);
package org.opendaylight.netconf.impl;
-import com.google.common.base.Function;
import com.google.common.base.Preconditions;
import com.google.common.collect.Collections2;
import com.google.common.collect.ImmutableSet;
}
public static Set<String> transformCapabilities(final Capabilities capabilities) {
- return Sets.newHashSet(Collections2.transform(capabilities.getCapability(), new Function<Uri, String>() {
- @Override
- public String apply(final Uri uri) {
- return uri.getValue();
- }
- }));
+ return Sets.newHashSet(Collections2.transform(capabilities.getCapability(), Uri::getValue));
}
}
private static final List<Schema.Location> NETCONF_LOCATIONS = ImmutableList.of(NETCONF_LOCATION);
private static final BasicCapability CANDIDATE_CAPABILITY =
new BasicCapability("urn:ietf:params:netconf:capability:candidate:1.0");
- private static final Function<Capability, Uri> CAPABILITY_TO_URI = new Function<Capability, Uri>() {
- @Override
- public Uri apply(final Capability input) {
- return new Uri(input.getCapabilityUri());
- }
- };
+ private static final Function<Capability, Uri> CAPABILITY_TO_URI = input -> new Uri(input.getCapabilityUri());
private final NetconfOperationServiceFactory netconfOperationProvider;
private final Map<Uri, Capability> capabilities = Maps.newHashMap();
revision.get(), revisionMapRequest.keySet());
return schema;
- } else {
- Preconditions.checkState(revisionMapRequest.size() == 1,
- "Expected 1 capability for module %s, available revisions : %s", moduleName,
- revisionMapRequest.keySet());
- //Only one revision is present, so return it
- return revisionMapRequest.values().iterator().next();
}
+
+ Preconditions.checkState(revisionMapRequest.size() == 1,
+ "Expected 1 capability for module %s, available revisions : %s", moduleName,
+ revisionMapRequest.keySet());
+ //Only one revision is present, so return it
+ return revisionMapRequest.values().iterator().next();
}
private void updateCapabilityToSchemaMap(final Set<Capability> added, final Set<Capability> removed) {
}
}
- private static boolean isValidModuleCapability(Capability cap) {
+ private static boolean isValidModuleCapability(final Capability cap) {
return cap.getModuleName().isPresent()
&& cap.getRevision().isPresent()
&& cap.getCapabilitySchema().isPresent();
listeners.add(listener);
listener.onCapabilitiesChanged(getCapabilities());
listener.onSchemasChanged(getSchemas());
- return new AutoCloseable() {
- @Override
- public void close() throws Exception {
- synchronized (NetconfCapabilityMonitoringService.this) {
- listeners.remove(listener);
- }
+ return () -> {
+ synchronized (NetconfCapabilityMonitoringService.this) {
+ listeners.remove(listener);
}
};
}
}
@Override
- public synchronized void onCapabilitiesChanged(Set<Capability> added, Set<Capability> removed) {
+ public synchronized void onCapabilitiesChanged(final Set<Capability> added, final Set<Capability> removed) {
onCapabilitiesAdded(added);
onCapabilitiesRemoved(removed);
updateCapabilityToSchemaMap(added, removed);
}
}
- private void notifyCapabilityChanged(Capabilities capabilities) {
+ private void notifyCapabilityChanged(final Capabilities capabilities) {
for (NetconfMonitoringService.CapabilitiesListener listener : listeners) {
listener.onCapabilitiesChanged(capabilities);
listener.onSchemasChanged(getSchemas());
private void onCapabilitiesRemoved(final Set<Capability> removedCaps) {
for (final Capability addedCap : removedCaps) {
- capabilities.remove(CAPABILITY_TO_URI.apply(addedCap));
+ capabilities.remove(new Uri(addedCap.getCapabilityUri()));
}
}
import static org.junit.Assert.fail;
import static org.mockito.Mockito.doReturn;
-import com.google.common.base.Function;
import com.google.common.base.Throwables;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
}
public Set<String> getServiceReferences(final List<ObjectName> testingDeps) {
- return new HashSet<>(Lists.transform(testingDeps, new Function<ObjectName, String>() {
- @Override
- public String apply(final ObjectName input) {
- return ObjectNameUtil.getReferenceName(input);
- }
- }));
+ return new HashSet<>(Lists.transform(testingDeps, ObjectNameUtil::getReferenceName));
}
public void commit(final TestingNetconfClient netconfClient) throws Exception {
package org.opendaylight.netconf.monitoring.xml.model;
-import com.google.common.base.Function;
import com.google.common.base.Preconditions;
import com.google.common.collect.Collections2;
import java.util.Collection;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
import javax.xml.bind.annotation.XmlElement;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.Yang;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.schemas.Schema;
private final Schema schema;
- MonitoringSchema(Schema schema) {
+ MonitoringSchema(final Schema schema) {
this.schema = schema;
}
@XmlElement(name = "location")
public Collection<String> getLocation() {
- return Collections2.transform(schema.getLocation(), new Function<Schema.Location, String>() {
- @Nullable
- @Override
- public String apply(@Nonnull Schema.Location input) {
- return input.getEnumeration().toString();
- }
- });
+ return Collections2.transform(schema.getLocation(), input -> input.getEnumeration().toString());
}
@XmlElement(name = "version")
*/
package org.opendaylight.netconf.monitoring.xml.model;
-import com.google.common.base.Function;
import com.google.common.collect.Collections2;
import java.util.Collection;
-import javax.annotation.Nullable;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlRootElement;
import org.opendaylight.netconf.monitoring.MonitoringConstants;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Schemas;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Sessions;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.schemas.Schema;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.sessions.Session;
@XmlRootElement(name = MonitoringConstants.NETCONF_MONITORING_XML_ROOT_ELEMENT)
public final class NetconfState {
@XmlElementWrapper(name = "schemas")
@XmlElement(name = "schema")
public Collection<MonitoringSchema> getSchemas() {
- return Collections2.transform(schemas.getSchema(), new Function<Schema, MonitoringSchema>() {
- @Nullable
- @Override
- public MonitoringSchema apply(@Nullable final Schema input) {
- return new MonitoringSchema(input);
- }
- });
+ return Collections2.transform(schemas.getSchema(), MonitoringSchema::new);
}
@XmlElementWrapper(name = "sessions")
@XmlElement(name = "session")
public Collection<MonitoringSession> getSessions() {
- return Collections2.transform(sessions.getSession(), new Function<Session, MonitoringSession>() {
- @Nullable
- @Override
- public MonitoringSession apply(@Nullable final Session input) {
- return new MonitoringSession(input);
- }
- });
+ return Collections2.transform(sessions.getSession(), MonitoringSession::new);
}
}
package org.opendaylight.netconf.util.messages;
-import com.google.common.base.Function;
import com.google.common.base.Optional;
import com.google.common.collect.Collections2;
import java.util.Collection;
private NetconfMessageUtil() {}
- public static boolean isOKMessage(NetconfMessage message) throws NetconfDocumentedException {
+ public static boolean isOKMessage(final NetconfMessage message) throws NetconfDocumentedException {
return isOKMessage(message.getDocument());
}
- public static boolean isOKMessage(Document document) throws NetconfDocumentedException {
+ public static boolean isOKMessage(final Document document) throws NetconfDocumentedException {
return isOKMessage(XmlElement.fromDomDocument(document));
}
- public static boolean isOKMessage(XmlElement xmlElement) throws NetconfDocumentedException {
+ public static boolean isOKMessage(final XmlElement xmlElement) throws NetconfDocumentedException {
if (xmlElement.getChildElements().size() != 1) {
return false;
}
}
}
- public static boolean isErrorMessage(NetconfMessage message) throws NetconfDocumentedException {
+ public static boolean isErrorMessage(final NetconfMessage message) throws NetconfDocumentedException {
return isErrorMessage(message.getDocument());
}
- public static boolean isErrorMessage(Document document) throws NetconfDocumentedException {
+ public static boolean isErrorMessage(final Document document) throws NetconfDocumentedException {
return isErrorMessage(XmlElement.fromDomDocument(document));
}
- public static boolean isErrorMessage(XmlElement xmlElement) throws NetconfDocumentedException {
+ public static boolean isErrorMessage(final XmlElement xmlElement) throws NetconfDocumentedException {
if (xmlElement.getChildElements().size() != 1) {
return false;
}
}
}
- public static Collection<String> extractCapabilitiesFromHello(Document doc) throws NetconfDocumentedException {
+ public static Collection<String> extractCapabilitiesFromHello(final Document doc)
+ throws NetconfDocumentedException {
XmlElement responseElement = XmlElement.fromDomDocument(doc);
// Extract child element <capabilities> from <hello> with or without(fallback) the same namespace
Optional<XmlElement> capabilitiesElement = responseElement
.getOnlyChildElementOptionally(XmlNetconfConstants.CAPABILITIES));
List<XmlElement> caps = capabilitiesElement.get().getChildElements(XmlNetconfConstants.CAPABILITY);
- return Collections2.transform(caps, new Function<XmlElement, String>() {
-
- @Override
- public String apply(@Nonnull XmlElement input) {
- // Trim possible leading/tailing whitespace
- try {
- return input.getTextContent().trim();
- } catch (DocumentedException e) {
- LOG.trace("Error fetching input text content",e);
- return null;
- }
+ return Collections2.transform(caps, (@Nonnull final XmlElement input) -> {
+ // Trim possible leading/tailing whitespace
+ try {
+ return input.getTextContent().trim();
+ } catch (DocumentedException e) {
+ LOG.trace("Error fetching input text content",e);
+ return null;
}
});
*/
package org.opendaylight.netconf.sal.connect.netconf;
-import com.google.common.base.Function;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicates;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
+import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
private static final Logger LOG = LoggerFactory.getLogger(NetconfDevice.class);
- public static final Function<QName, SourceIdentifier> QNAME_TO_SOURCE_ID_FUNCTION =
- input -> RevisionSourceIdentifier.create(input.getLocalName(),
- Optional.fromNullable(input.getFormattedRevision()));
-
protected final RemoteDeviceId id;
private final boolean reconnectOnSchemasChange;
private final NetconfDeviceSchemasResolver stateSchemasResolver;
private final NotificationHandler notificationHandler;
protected final List<SchemaSourceRegistration<? extends SchemaSourceRepresentation>> sourceRegistrations =
- Lists.newArrayList();
+ new ArrayList<>();
@GuardedBy("this")
private boolean connected = false;
}
public Collection<SourceIdentifier> getRequiredSources() {
- return Collections2.transform(requiredSources, QNAME_TO_SOURCE_ID_FUNCTION);
+ return Collections2.transform(requiredSources, DeviceSources::toSourceId);
}
public Collection<SourceIdentifier> getProvidedSources() {
- return Collections2.transform(providedSources, QNAME_TO_SOURCE_ID_FUNCTION);
+ return Collections2.transform(providedSources, DeviceSources::toSourceId);
}
public SchemaSourceProvider<YangTextSchemaSource> getSourceProvider() {
return sourceProvider;
}
+
+ private static SourceIdentifier toSourceId(final QName input) {
+ return RevisionSourceIdentifier.create(input.getLocalName(),
+ Optional.fromNullable(input.getFormattedRevision()));
+ }
}
/**
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.toPath;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Function;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
@Override
public Set<QName> getAvailableYangSchemasQNames() {
- return Sets.newHashSet(Collections2.transform(getAvailableYangSchemas(),
- new Function<RemoteYangSchema, QName>() {
- @Override
- public QName apply(final RemoteYangSchema input) {
- return input.getQName();
- }
- }));
+ return Sets.newHashSet(Collections2.transform(getAvailableYangSchemas(), RemoteYangSchema::getQName));
}
/**
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
import java.util.Collection;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
*/
public final class NetconfDeviceRpc implements DOMRpcService {
- private static final Function<RpcDefinition, DOMRpcIdentifier> RPC_TO_RPC_IDENTIFIER =
- new Function<RpcDefinition, DOMRpcIdentifier>() {
- @Override
- public DOMRpcIdentifier apply(final RpcDefinition input) {
- return DOMRpcIdentifier.create(input.getPath());
- }
- };
-
private final RemoteDeviceCommunicator<NetconfMessage> listener;
private final MessageTransformer<NetconfMessage> transformer;
private final Collection<DOMRpcIdentifier> availableRpcs;
this.listener = listener;
this.transformer = transformer;
- availableRpcs = Collections2.transform(schemaContext.getOperations(), RPC_TO_RPC_IDENTIFIER);
+ availableRpcs = Collections2.transform(schemaContext.getOperations(),
+ input -> DOMRpcIdentifier.create(input.getPath()));
}
@Nonnull
listener.sendRequest(message, type.getLastComponent());
final ListenableFuture<DOMRpcResult> transformed =
- Futures.transform(delegateFutureWithPureResult, new Function<RpcResult<NetconfMessage>, DOMRpcResult>() {
- @Override
- public DOMRpcResult apply(final RpcResult<NetconfMessage> input) {
- if (input.isSuccessful()) {
- return transformer.toRpcResult(input.getResult(), type);
- } else {
- return new DefaultDOMRpcResult(input.getErrors());
- }
+ Futures.transform(delegateFutureWithPureResult, input1 -> {
+ if (input1.isSuccessful()) {
+ return transformer.toRpcResult(input1.getResult(), type);
+ } else {
+ return new DefaultDOMRpcResult(input1.getErrors());
}
- });
+ }, MoreExecutors.directExecutor());
return Futures.makeChecked(transformed, new Function<Exception, DOMRpcException>() {
@Nullable
package org.opendaylight.netconf.sal.connect.netconf.sal;
-import com.google.common.base.Function;
import com.google.common.base.Preconditions;
-import com.google.common.collect.FluentIterable;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import java.util.ArrayList;
import java.util.List;
-import java.util.Map.Entry;
+import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.connection.status.UnavailableCapabilities;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.connection.status.UnavailableCapabilitiesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.connection.status.available.capabilities.AvailableCapability;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.connection.status.unavailable.capabilities.UnavailableCapability;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.connection.status.unavailable.capabilities.UnavailableCapability.FailureReason;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.connection.status.unavailable.capabilities.UnavailableCapabilityBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.network.topology.topology.topology.types.TopologyNetconf;
public final class NetconfDeviceTopologyAdapter implements AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(NetconfDeviceTopologyAdapter.class);
- public static final Function<Entry<QName, FailureReason>, UnavailableCapability>
- UNAVAILABLE_CAPABILITY_TRANSFORMER =
- input -> new UnavailableCapabilityBuilder()
- .setCapability(input.getKey().toString()).setFailureReason(input.getValue()).build();
private final RemoteDeviceId id;
private BindingTransactionChain txChain;
nodeBuilder.addAugmentation(NetconfNode.class, netconfNodeBuilder.build());
Node node = nodeBuilder.build();
- LOG.trace(
- "{}: Init device state transaction {} putting if absent operational data started.",
+ LOG.trace("{}: Init device state transaction {} putting if absent operational data started.",
id, writeTx.getIdentifier());
writeTx.put(LogicalDatastoreType.OPERATIONAL, path, node);
- LOG.trace(
- "{}: Init device state transaction {} putting operational data ended.",
- id, writeTx.getIdentifier());
-
- LOG.trace(
- "{}: Init device state transaction {} putting if absent config data started.",
- id, writeTx.getIdentifier());
- LOG.trace(
- "{}: Init device state transaction {} putting config data ended.",
+ LOG.trace("{}: Init device state transaction {} putting operational data ended.", id, writeTx.getIdentifier());
+ LOG.trace("{}: Init device state transaction {} putting if absent config data started.",
id, writeTx.getIdentifier());
+ LOG.trace("{}: Init device state transaction {} putting config data ended.", id, writeTx.getIdentifier());
commitTransaction(writeTx, "init");
}
final NetconfNode data = buildDataForNetconfNode(up, capabilities);
final WriteTransaction writeTx = txChain.newWriteOnlyTransaction();
- LOG.trace(
- "{}: Update device state transaction {} merging operational data started.",
+ LOG.trace("{}: Update device state transaction {} merging operational data started.",
id, writeTx.getIdentifier());
- writeTx.put(LogicalDatastoreType.OPERATIONAL,
- id.getTopologyBindingPath().augmentation(NetconfNode.class), data, true);
- LOG.trace(
- "{}: Update device state transaction {} merging operational data ended.",
+ writeTx.put(LogicalDatastoreType.OPERATIONAL, id.getTopologyBindingPath().augmentation(NetconfNode.class),
+ data, true);
+ LOG.trace("{}: Update device state transaction {} merging operational data ended.",
id, writeTx.getIdentifier());
commitTransaction(writeTx, "update");
final NetconfNode data = buildDataForNetconfClusteredNode(up, masterAddress, capabilities);
final WriteTransaction writeTx = txChain.newWriteOnlyTransaction();
- LOG.trace(
- "{}: Update device state transaction {} merging operational data started.",
+ LOG.trace("{}: Update device state transaction {} merging operational data started.",
id, writeTx.getIdentifier());
writeTx.put(LogicalDatastoreType.OPERATIONAL,
id.getTopologyBindingPath().augmentation(NetconfNode.class), data, true);
- LOG.trace(
- "{}: Update device state transaction {} merging operational data ended.",
+ LOG.trace("{}: Update device state transaction {} merging operational data ended.",
id, writeTx.getIdentifier());
commitTransaction(writeTx, "update");
}
public void setDeviceAsFailed(final Throwable throwable) {
- String reason = (throwable != null && throwable.getMessage() != null) ? throwable.getMessage() : UNKNOWN_REASON;
+ String reason = throwable != null && throwable.getMessage() != null ? throwable.getMessage() : UNKNOWN_REASON;
final NetconfNode data = new NetconfNodeBuilder()
.setConnectionStatus(ConnectionStatus.UnableToConnect).setConnectedMessage(reason).build();
final AvailableCapabilitiesBuilder avCapabalitiesBuilder = new AvailableCapabilitiesBuilder();
avCapabalitiesBuilder.setAvailableCapability(capabilityList);
- final UnavailableCapabilities unavailableCapabilities = new UnavailableCapabilitiesBuilder()
- .setUnavailableCapability(FluentIterable.from(capabilities.getUnresolvedCapabilites().entrySet())
- .transform(UNAVAILABLE_CAPABILITY_TRANSFORMER).toList()).build();
-
final NetconfNodeBuilder netconfNodeBuilder = new NetconfNodeBuilder()
.setHost(id.getHost())
.setPort(new PortNumber(id.getAddress().getPort()))
.setConnectionStatus(up ? ConnectionStatus.Connected : ConnectionStatus.Connecting)
.setAvailableCapabilities(avCapabalitiesBuilder.build())
- .setUnavailableCapabilities(unavailableCapabilities);
+ .setUnavailableCapabilities(unavailableCapabilities(capabilities.getUnresolvedCapabilites()));
return netconfNodeBuilder.build();
}
final AvailableCapabilitiesBuilder avCapabalitiesBuilder = new AvailableCapabilitiesBuilder();
avCapabalitiesBuilder.setAvailableCapability(capabilityList);
- final UnavailableCapabilities unavailableCapabilities =
- new UnavailableCapabilitiesBuilder().setUnavailableCapability(capabilities.getUnresolvedCapabilites()
- .entrySet().stream().map(UNAVAILABLE_CAPABILITY_TRANSFORMER::apply)
- .collect(Collectors.toList())).build();
-
final NetconfNodeBuilder netconfNodeBuilder = new NetconfNodeBuilder()
.setHost(id.getHost())
.setPort(new PortNumber(id.getAddress().getPort()))
.setConnectionStatus(up ? ConnectionStatus.Connected : ConnectionStatus.Connecting)
.setAvailableCapabilities(avCapabalitiesBuilder.build())
- .setUnavailableCapabilities(unavailableCapabilities)
+ .setUnavailableCapabilities(unavailableCapabilities(capabilities.getUnresolvedCapabilites()))
.setClusteredConnectionStatus(
new ClusteredConnectionStatusBuilder().setNetconfMasterNode(masterNodeAddress).build());
return netconfNodeBuilder.build();
}
+ private static UnavailableCapabilities unavailableCapabilities(final Map<QName, FailureReason> input) {
+ return new UnavailableCapabilitiesBuilder().setUnavailableCapability(input.entrySet().stream().map(
+ e -> new UnavailableCapabilityBuilder().setCapability(e.getKey().toString()).setFailureReason(
+ e.getValue()).build()).collect(Collectors.toList())).build();
+ }
+
public void removeDeviceConfiguration() {
final WriteTransaction writeTx = txChain.newWriteOnlyTransaction();
}
});
- return Futures.makeChecked(transformed, new Function<Exception, DOMRpcException>() {
- @Nullable
- @Override
- public DOMRpcException apply(@Nullable final Exception exception) {
- return new DOMRpcImplementationNotAvailableException(
- exception, "Unable to invoke rpc %s on device %s", type, deviceId);
- }
- });
+ return Futures.makeChecked(transformed,
+ e -> new DOMRpcImplementationNotAvailableException(e,
+ "Unable to invoke rpc %s on device %s", type, deviceId));
}
-
private static boolean isBaseRpc(final SchemaPath type) {
return NetconfMessageTransformUtil.NETCONF_URI.equals(type.getLastComponent().getNamespace());
}
@Override
public synchronized CheckedFuture<Void, TransactionCommitFailedException> submit() {
final ListenableFuture<Void> commitFutureAsVoid = Futures.transform(commit(),
- new Function<RpcResult<TransactionStatus>, Void>() {
- @Override
- public Void apply(final RpcResult<TransactionStatus> input) {
- Preconditions.checkArgument(input.isSuccessful() && input.getErrors().isEmpty(),
- "Submit failed with errors: %s", input.getErrors());
- return null;
- }
- });
-
- return Futures.makeChecked(commitFutureAsVoid, new Function<Exception, TransactionCommitFailedException>() {
- @Override
- public TransactionCommitFailedException apply(final Exception input) {
- return new TransactionCommitFailedException(
- "Submit of transaction " + getIdentifier() + " failed", input);
- }
- });
+ (Function<RpcResult<TransactionStatus>, Void>) input -> {
+ Preconditions.checkArgument(input.isSuccessful() && input.getErrors().isEmpty(),
+ "Submit failed with errors: %s", input.getErrors());
+ return null;
+ });
+
+ return Futures.makeChecked(commitFutureAsVoid, input -> new TransactionCommitFailedException(
+ "Submit of transaction " + getIdentifier() + " failed", input));
}
/**
@Override
public synchronized CheckedFuture<Void, TransactionCommitFailedException> submit() {
final ListenableFuture<Void> commmitFutureAsVoid = Futures.transform(commit(),
- new Function<RpcResult<TransactionStatus>, Void>() {
- @Override
- public Void apply(final RpcResult<TransactionStatus> input) {
- return null;
- }
- });
-
- return Futures.makeChecked(commmitFutureAsVoid, new Function<Exception, TransactionCommitFailedException>() {
- @Override
- public TransactionCommitFailedException apply(final Exception input) {
- return new TransactionCommitFailedException("Submit of transaction " + getIdentifier() + " failed",
- input);
- }
- });
+ (Function<RpcResult<TransactionStatus>, Void>) input -> null);
+
+ return Futures.makeChecked(commmitFutureAsVoid,
+ input -> new TransactionCommitFailedException("Submit of transaction " + getIdentifier() + " failed",
+ input));
}
@Override
final boolean rollbackSupport) {
final NetconfRpcFutureCallback editConfigCallback = new NetconfRpcFutureCallback("Edit running", id);
if (defaultOperation.isPresent()) {
- return netOps.editConfigRunning(
- editConfigCallback, editStructure, defaultOperation.get(), rollbackSupport);
+ return netOps.editConfigRunning(editConfigCallback, editStructure, defaultOperation.get(),
+ rollbackSupport);
} else {
return netOps.editConfigRunning(editConfigCallback, editStructure, rollbackSupport);
}
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_URI;
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.toPath;
-import com.google.common.base.Function;
import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
import com.google.common.collect.Multimap;
private static final Logger LOG = LoggerFactory.getLogger(NetconfMessageTransformer.class);
- private static final Function<SchemaNode, QName> QNAME_FUNCTION = rpcDefinition -> rpcDefinition.getQName();
-
- private static final Function<SchemaNode, QName> QNAME_NOREV_FUNCTION =
- notification -> QNAME_FUNCTION.apply(notification).withoutRevision();
-
private final SchemaContext schemaContext;
private final BaseSchema baseSchema;
private final MessageCounter counter;
this.schemaContext = schemaContext;
parserFactory = DomToNormalizedNodeParserFactory
.getInstance(XmlUtils.DEFAULT_XML_CODEC_PROVIDER, schemaContext, strictParsing);
- mappedRpcs = Maps.uniqueIndex(schemaContext.getOperations(), QNAME_FUNCTION);
- mappedNotifications = Multimaps.index(schemaContext.getNotifications(), QNAME_NOREV_FUNCTION);
+ mappedRpcs = Maps.uniqueIndex(schemaContext.getOperations(), SchemaNode::getQName);
+ mappedNotifications = Multimaps.index(schemaContext.getNotifications(),
+ node -> node.getQName().withoutRevision());
this.baseSchema = baseSchema;
}
// use default pre build context with just the base model
// This way operations like lock/unlock are supported even if the source for base model was not provided
SchemaContext ctx = needToUseBaseCtx ? baseSchema.getSchemaContext() : schemaContext;
- NetconfMessageTransformUtil.writeNormalizedRpc(((ContainerNode) payload), result, rpc, ctx);
+ NetconfMessageTransformUtil.writeNormalizedRpc((ContainerNode) payload, result, rpc, ctx);
} catch (final XMLStreamException | IOException | IllegalStateException e) {
throw new IllegalStateException("Unable to serialize " + rpc, e);
}
}
private static Map<QName, DataSchemaNode> asMap(final Collection<DataSchemaNode> childNodes) {
- return Maps.uniqueIndex(childNodes, new Function<DataSchemaNode, QName>() {
- @Override
- public QName apply(final DataSchemaNode input) {
- return input.getQName();
- }
- });
+ return Maps.uniqueIndex(childNodes, (Function<DataSchemaNode, QName>) DataSchemaNode::getQName);
}
@Override
Code Review / netconf.git / commitdiff