Migrate pcep to MD-SAL APIs

[bgpcep.git] / pcep / topology / topology-provider / src / main / java / org / opendaylight / bgpcep / pcep / topology / provider / PCEPStatefulPeerProposal.java

diff --git a/pcep/topology/topology-provider/src/main/java/org/opendaylight/bgpcep/pcep/topology/provider/PCEPStatefulPeerProposal.java b/pcep/topology/topology-provider/src/main/java/org/opendaylight/bgpcep/pcep/topology/provider/PCEPStatefulPeerProposal.java
index 9594186b16f51f971c80ffd644bde86585ad9104..c601e623a16d5a86ec66e2b4cc1e8711ded50381 100644 (file)
--- a/pcep/topology/topology-provider/src/main/java/org/opendaylight/bgpcep/pcep/topology/provider/PCEPStatefulPeerProposal.java
+++ b/pcep/topology/topology-provider/src/main/java/org/opendaylight/bgpcep/pcep/topology/provider/PCEPStatefulPeerProposal.java
@@ -10,19 +10,18 @@ package org.opendaylight.bgpcep.pcep.topology.provider;
 
 import static java.util.Objects.requireNonNull;
 
-import com.google.common.base.Optional;
-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 org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.pcep.sync.optimizations.rev171025.PathComputationClient1;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.pcep.sync.optimizations.rev171025.Stateful1;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.pcep.sync.optimizations.rev171025.Tlvs3;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.pcep.sync.optimizations.rev171025.Tlvs3Builder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.pcep.sync.optimizations.rev171025.lsp.db.version.tlv.LspDbVersion;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.pcep.sync.optimizations.rev171025.speaker.entity.id.tlv.SpeakerEntityIdBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev171025.Tlvs1;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.open.object.open.TlvsBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev171025.Node1;
@@ -35,7 +34,7 @@ import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-public final class PCEPStatefulPeerProposal {
+final class PCEPStatefulPeerProposal {
 
     private static final Logger LOG = LoggerFactory.getLogger(PCEPStatefulPeerProposal.class);
 
@@ -52,39 +51,43 @@ public final class PCEPStatefulPeerProposal {
         return new PCEPStatefulPeerProposal(dataBroker, topologyId);
     }
 
-    void setPeerProposal(final NodeId nodeId, final TlvsBuilder openTlvsBuilder) {
+    void setPeerProposal(final NodeId nodeId, final TlvsBuilder openTlvsBuilder, final byte[] speakerId) {
         if (isSynOptimizationEnabled(openTlvsBuilder)) {
-            try (final ReadOnlyTransaction rTx = this.dataBroker.newReadOnlyTransaction()) {
+            Optional<LspDbVersion> result = Optional.empty();
+            try (ReadTransaction rTx = this.dataBroker.newReadOnlyTransaction()) {
                 final ListenableFuture<Optional<LspDbVersion>> future = rTx.read(
-                    LogicalDatastoreType.OPERATIONAL,
-                    this.topologyId.child(Node.class, new NodeKey(nodeId)).augmentation(Node1.class)
-                    .child(PathComputationClient.class).augmentation(PathComputationClient1.class)
-                    .child(LspDbVersion.class));
-                Futures.addCallback(future, new FutureCallback<Optional<LspDbVersion>>() {
-                    @Override
-                    public void onSuccess(final Optional<LspDbVersion> result) {
-                        if (result.isPresent()) {
-                            openTlvsBuilder.addAugmentation(Tlvs3.class,
-                                new Tlvs3Builder().setLspDbVersion(result.get()).build());
-                        }
-                    }
+                        LogicalDatastoreType.OPERATIONAL,
+                        this.topologyId.child(Node.class, new NodeKey(nodeId)).augmentation(Node1.class)
+                                .child(PathComputationClient.class).augmentation(PathComputationClient1.class)
+                                .child(LspDbVersion.class));
+                try {
+                    result = future.get();
+                } catch (final InterruptedException | ExecutionException e) {
+                    LOG.warn("Failed to read toplogy {}.", InstanceIdentifier.keyOf(
+                            PCEPStatefulPeerProposal.this.topologyId), e);
 
-                    @Override
-                    public void onFailure(final Throwable t) {
-                        LOG.warn("Failed to read toplogy {}.", InstanceIdentifier.keyOf(
-                            PCEPStatefulPeerProposal.this.topologyId), t);
-                    }
-                }, MoreExecutors.directExecutor());
+                }
             }
+            if (speakerId == null && !result.isPresent()) {
+                return;
+            }
+            final Tlvs3Builder syncBuilder = new Tlvs3Builder();
+
+            if (result.isPresent()) {
+                syncBuilder.setLspDbVersion(result.get());
+            }
+            if (speakerId != null) {
+                syncBuilder.setSpeakerEntityId(new SpeakerEntityIdBuilder().setSpeakerEntityIdValue(speakerId).build());
+            }
+            openTlvsBuilder.addAugmentation(Tlvs3.class, syncBuilder.build()).build();
         }
     }
 
     private static boolean isSynOptimizationEnabled(final TlvsBuilder openTlvsBuilder) {
-        final Tlvs1 statefulTlv = openTlvsBuilder.getAugmentation(Tlvs1.class);
+        final Tlvs1 statefulTlv = openTlvsBuilder.augmentation(Tlvs1.class);
         if (statefulTlv != null && statefulTlv.getStateful() != null) {
-            return statefulTlv.getStateful().getAugmentation(Stateful1.class) != null;
+            return statefulTlv.getStateful().augmentation(Stateful1.class) != null;
         }
         return false;
     }
-
 }