import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.net.InetAddress;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
-import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Optional;
-import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicLong;
import org.checkerframework.checker.lock.qual.GuardedBy;
+import org.checkerframework.checker.lock.qual.Holding;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.bgpcep.pcep.server.PathComputation;
import org.opendaylight.bgpcep.pcep.server.PceServerProvider;
-import org.opendaylight.protocol.pcep.PCEPSession;
import org.opendaylight.protocol.pcep.spi.PCEPErrors;
import org.opendaylight.protocol.pcep.spi.PSTUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.pcep.sync.optimizations.rev200720.PathComputationClient1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.initiated.rev200720.PcinitiateBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.initiated.rev200720.Srp1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.initiated.rev200720.Srp1Builder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.initiated.rev200720.Stateful1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.initiated.rev200720.pcinitiate.message.PcinitiateMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.initiated.rev200720.pcinitiate.message.pcinitiate.message.Requests;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.initiated.rev200720.pcinitiate.message.pcinitiate.message.RequestsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.PcupdBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.PlspId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.SrpIdNumber;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.StatefulTlv1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.SymbolicPathName;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.Tlvs1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.lsp.object.Lsp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.lsp.object.LspBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.lsp.object.lsp.TlvsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.pcupd.message.pcupd.message.updates.PathBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.srp.object.Srp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.srp.object.SrpBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.stateful.capability.tlv.Stateful;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.symbolic.path.name.tlv.SymbolicPathNameBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev181109.Pcerr;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev181109.PcerrBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.PcerrMessage;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.RequestId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.explicit.route.object.EroBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.open.object.open.Tlvs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.path.setup.type.tlv.PathSetupType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcep.error.object.ErrorObjectBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcerr.message.PcerrMessageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.pcep.client.attributes.PathComputationClientBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.pcep.client.attributes.path.computation.client.ReportedLsp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.pcep.client.attributes.path.computation.client.ReportedLspBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.pcep.client.attributes.path.computation.client.StatefulTlvBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.pcep.client.attributes.path.computation.client.reported.lsp.Path;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.util.BindingMap;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-class PCEPTopologySessionListener extends AbstractTopologySessionListener<SrpIdNumber, PlspId> {
+// Non-final for testing
+class PCEPTopologySessionListener extends AbstractTopologySessionListener {
private static final Logger LOG = LoggerFactory.getLogger(PCEPTopologySessionListener.class);
private static final PlspId PLSPID_ZERO = new PlspId(Uint32.ZERO);
+ private static final SrpIdNumber SRPID_ZERO = new SrpIdNumber(Uint32.ZERO);
private final AtomicLong requestId = new AtomicLong(1L);
@GuardedBy("this")
private final List<PlspId> staleLsps = new ArrayList<>();
- private final AtomicBoolean statefulCapability = new AtomicBoolean(false);
- private final AtomicBoolean lspUpdateCapability = new AtomicBoolean(false);
- private final AtomicBoolean initiationCapability = new AtomicBoolean(false);
-
private final PceServerProvider pceServerProvider;
/**
*/
PCEPTopologySessionListener(final ServerSessionManager serverSessionManager) {
super(serverSessionManager);
- this.pceServerProvider = serverSessionManager.getPCEPTopologyProviderDependencies().getPceServerProvider();
+ pceServerProvider = serverSessionManager.getPCEPTopologyProviderDependencies().getPceServerProvider();
}
private static LspDbVersion geLspDbVersionTlv(final Lsp lsp) {
- final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.lsp.object
- .lsp.Tlvs tlvs = lsp.getTlvs();
- if (tlvs != null && tlvs.augmentation(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang
- .controller.pcep.sync.optimizations.rev200720.Tlvs1.class) != null) {
- return tlvs.augmentation(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller
- .pcep.sync.optimizations.rev200720.Tlvs1.class).getLspDbVersion();
- }
- return null;
- }
-
- @Override
- protected void onSessionUp(final PCEPSession session, final PathComputationClientBuilder pccBuilder) {
- final InetAddress peerAddress = session.getRemoteAddress();
-
- final Tlvs tlvs = session.getRemoteTlvs();
- if (tlvs != null && tlvs.augmentation(Tlvs1.class) != null) {
- final Stateful stateful = tlvs.augmentation(Tlvs1.class).getStateful();
- if (stateful != null) {
- setStatefulCapabilities(stateful);
- pccBuilder.setReportedLsp(Collections.emptyMap());
- if (isSynchronized()) {
- pccBuilder.setStateSync(PccSyncState.Synchronized);
- } else if (isTriggeredInitialSynchro()) {
- pccBuilder.setStateSync(PccSyncState.TriggeredInitialSync);
- } else if (isIncrementalSynchro()) {
- pccBuilder.setStateSync(PccSyncState.IncrementalSync);
- } else {
- pccBuilder.setStateSync(PccSyncState.InitialResync);
- }
- pccBuilder.setStatefulTlv(new StatefulTlvBuilder().addAugmentation(
- new StatefulTlv1Builder(tlvs.augmentation(Tlvs1.class)).build()).build());
- } else {
- LOG.debug("Peer {} does not advertise stateful TLV", peerAddress);
+ final var tlvs = lsp.getTlvs();
+ if (tlvs != null) {
+ final var tlvs1 = tlvs.augmentation(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang
+ .controller.pcep.sync.optimizations.rev200720.Tlvs1.class);
+ if (tlvs1 != null) {
+ return tlvs1.getLspDbVersion();
}
- } else {
- LOG.debug("Peer {} does not advertise stateful TLV", peerAddress);
}
+ return null;
}
@Override
updBuilder.setPath(pb.build());
updBuilder.setLsp(lsp).setSrp(srp).setPath(pb.build());
- pcupdMessageBuilder.setUpdates(Collections.singletonList(updBuilder.build()));
+ pcupdMessageBuilder.setUpdates(List.of(updBuilder.build()));
return srp.getOperationId();
}
+ @Holding("this")
private void markAllLspAsStale() {
- this.staleLsps.addAll(this.lsps.keySet());
+ staleLsps.addAll(lsps.keySet());
}
private boolean handleErrorMessage(final PcerrMessage message) {
- final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcerr.message
- .PcerrMessage errMsg = message.getPcerrMessage();
+ final var errMsg = message.getPcerrMessage();
if (errMsg.getErrorType() instanceof StatefulCase) {
final StatefulCase stat = (StatefulCase) errMsg.getErrorType();
- for (final Srps srps : stat.getStateful().getSrps()) {
+ for (final Srps srps : stat.getStateful().nonnullSrps()) {
final SrpIdNumber id = srps.getSrp().getOperationId();
- if (id.getValue().toJava() != 0) {
+ if (!SRPID_ZERO.equals(id)) {
final PCEPRequest req = removeRequest(id);
if (req != null) {
req.done(OperationResults.createFailed(errMsg.getErrors()));
return false;
}
final SrpIdNumber id = srp.getOperationId();
- if (id.getValue().toJava() == 0) {
+ if (SRPID_ZERO.equals(id)) {
return false;
}
switch (lsp.getOperational()) {
return true;
}
+ @Holding("this")
private boolean manageNextReport(final Reports report, final MessageContext ctx) {
final Lsp lsp = report.getLsp();
final PlspId plspid = lsp.getPlspId();
final Srp srp = report.getSrp();
- if (!lsp.isSync() && (plspid == null || plspid.getValue().toJava() == 0)) {
+ if (!lsp.getSync() && (plspid == null || PLSPID_ZERO.equals(plspid))) {
purgeStaleLsps(ctx);
if (isTriggeredSyncInProcess()) {
if (srp == null) {
return false;
}
final SrpIdNumber id = srp.getOperationId();
- if (id.getValue().toJava() == 0) {
+ if (SRPID_ZERO.equals(id)) {
return false;
}
final PCEPRequest req = removeRequest(id);
solicited = isSolicited(srp, lsp, ctx, rlb);
// if remove flag is set in SRP object, remove the tunnel immediately
- if (solicited && srp.augmentation(Srp1.class) != null) {
+ if (solicited) {
final Srp1 initiatedSrp = srp.augmentation(Srp1.class);
- if (initiatedSrp.isRemove()) {
+ if (initiatedSrp != null && initiatedSrp.getRemove()) {
super.removeLsp(ctx, plspid);
return false;
}
}
- rlb.setPath(Collections.singletonList(buildPath(report, srp, lsp)));
+ rlb.setPath(BindingMap.of(buildPath(report, srp, lsp)));
String name = lookupLspName(plspid);
if (lsp.getTlvs() != null && lsp.getTlvs().getSymbolicPathName() != null) {
updatePccNode(ctx, new PathComputationClientBuilder()
.addAugmentation(new PathComputationClient1Builder().setLspDbVersion(lspDbVersion).build()).build());
}
- updateLsp(ctx, plspid, name, rlb, solicited, lsp.isRemove());
+ updateLsp(ctx, plspid, name, rlb, solicited, lsp.getRemove());
unmarkStaleLsp(plspid);
LOG.debug("LSP {} updated", lsp);
pst = null;
}
pb.addAugmentation(p1Builder.build());
- final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.lsp
- .object.lsp.Tlvs tlvs = report.getLsp().getTlvs();
+ final var tlvs = report.getLsp().getTlvs();
if (tlvs != null) {
if (tlvs.getLspIdentifiers() != null) {
pb.setLspId(tlvs.getLspIdentifiers().getLspId());
private boolean handlePcreqMessage(final PcreqMessage message) {
LOG.info("Start PcRequest Message handler");
+ Message rep = null;
/* Get a Path Computation to compute the Path from the Request */
- PathComputation pathComputation = this.pceServerProvider.getPathComputation();
- Message rep = null;
+ // TODO: Adjust Junit Test to avoid this test
+ if (pceServerProvider == null) {
+ rep = createErrorMsg(PCEPErrors.RESOURCE_LIMIT_EXCEEDED, Uint32.ZERO);
+ sendMessage(rep, new SrpIdNumber(Uint32.ZERO), null);
+ return false;
+ }
+ PathComputation pathComputation = pceServerProvider.getPathComputation();
/* Reply with Error Message if no valid Path Computation is available */
if (pathComputation == null) {
rep = createErrorMsg(PCEPErrors.RESOURCE_LIMIT_EXCEEDED, Uint32.ZERO);
sendMessage(rep, new SrpIdNumber(Uint32.ZERO), null);
return false;
}
- for (org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq
- .message.Requests req : message.getRequests()) {
+ for (var req : message.nonnullRequests()) {
LOG.debug("Process request {}", req);
rep = pathComputation.computePath(req);
SrpIdNumber repId = null;
if (!(message instanceof PcrptMessage)) {
return true;
}
- this.listenerState.updateLastReceivedRptMsg();
- final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.pcrpt
- .message.PcrptMessage rpt = ((PcrptMessage) message).getPcrptMessage();
- for (final Reports report : rpt.getReports()) {
+ listenerState.updateLastReceivedRptMsg();
+ final var rpt = ((PcrptMessage) message).getPcrptMessage();
+ for (final Reports report : rpt.nonnullReports()) {
if (!manageNextReport(report, ctx)) {
return false;
}
}
private SrpIdNumber nextRequest() {
- return new SrpIdNumber(Uint32.valueOf(this.requestId.getAndIncrement()));
+ return new SrpIdNumber(Uint32.valueOf(requestId.getAndIncrement()));
}
@Override
}
final PcinitiateMessageBuilder ib = new PcinitiateMessageBuilder(MESSAGE_HEADER);
final Requests rb = buildRequest(rep, reportedLsp);
- ib.setRequests(Collections.singletonList(rb));
+ ib.setRequests(List.of(rb));
return sendMessage(new PcinitiateBuilder().setPcinitiateMessage(ib.build()).build(),
rb.getSrp().getOperationId(), null);
}, MoreExecutors.directExecutor());
}
rb.setSrp(srpBuilder.build());
rb.setLsp(new LspBuilder().setRemove(Boolean.FALSE).setPlspId(reportedLsp.getPlspId())
- .setDelegate(reportedLsp.isDelegate()).build());
+ .setDelegate(reportedLsp.getDelegate()).build());
return rb.build();
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private ListenableFuture<OperationResult> redelegate(final Lsp reportedLsp, final Srp srp, final Lsp lsp,
final UpdateLspArgs input) {
// the D bit that was reported decides the type of PCE message sent
- requireNonNull(reportedLsp.isDelegate());
+ final boolean isDelegate = requireNonNull(reportedLsp.getDelegate());
final Message msg;
- if (reportedLsp.isDelegate()) {
+ if (isDelegate) {
// we already have delegation, send update
final UpdatesBuilder rb = new UpdatesBuilder();
rb.setSrp(srp);
pb.fieldsFrom(input.getArguments());
rb.setPath(pb.build());
final PcupdMessageBuilder ub = new PcupdMessageBuilder(MESSAGE_HEADER);
- ub.setUpdates(Collections.singletonList(rb.build()));
+ ub.setUpdates(List.of(rb.build()));
msg = new PcupdBuilder().setPcupdMessage(ub.build()).build();
} else {
final Lsp1 lspCreateFlag = reportedLsp.augmentation(Lsp1.class);
// we only retake delegation for PCE initiated tunnels
- if (lspCreateFlag != null && !lspCreateFlag.isCreate()) {
+ if (lspCreateFlag != null && !lspCreateFlag.getCreate()) {
LOG.warn("Unable to retake delegation of PCC-initiated tunnel: {}", reportedLsp);
return OperationResults.createUnsent(PCEPErrors.UPDATE_REQ_FOR_NON_LSP).future();
}
@Override
@SuppressFBWarnings(value = "NP_NULL_ON_SOME_PATH", justification = "SB does not grok TYPE_USE")
-
public synchronized ListenableFuture<OperationResult> updateLsp(final UpdateLspArgs input) {
checkArgument(input != null && input.getName() != null && input.getNode() != null
&& input.getArguments() != null, MISSING_XML_TAG);
if (path1 != null) {
final PlspId plspId = path1.getLsp().getPlspId();
if (!incrementalSynchro) {
- this.staleLsps.add(plspId);
+ staleLsps.add(plspId);
}
lsps.put(plspId, lspName);
}
* @param plspId id
*/
private synchronized void unmarkStaleLsp(final PlspId plspId) {
- this.staleLsps.remove(plspId);
+ staleLsps.remove(plspId);
}
/**
* @param ctx message context
*/
private synchronized void purgeStaleLsps(final MessageContext ctx) {
- for (final PlspId plspId : this.staleLsps) {
+ for (final PlspId plspId : staleLsps) {
removeLsp(ctx, plspId);
}
- this.staleLsps.clear();
- }
-
- @Override
- public boolean isInitiationCapability() {
- return this.initiationCapability.get();
- }
-
- @Override
- public boolean isStatefulCapability() {
- return this.statefulCapability.get();
- }
-
- @Override
- public boolean isLspUpdateCapability() {
- return this.lspUpdateCapability.get();
- }
-
- private synchronized void setStatefulCapabilities(final Stateful stateful) {
- this.statefulCapability.set(true);
- if (stateful.isLspUpdateCapability() != null) {
- this.lspUpdateCapability.set(stateful.isLspUpdateCapability());
- }
- final Stateful1 stateful1 = stateful.augmentation(Stateful1.class);
- if (stateful1 != null && stateful1.isInitiation() != null) {
- this.initiationCapability.set(stateful1.isInitiation());
- }
+ staleLsps.clear();
}
private class ResyncLspFunction implements AsyncFunction<Optional<ReportedLsp>, OperationResult> {
-
private final TriggerSyncArgs input;
ResyncLspFunction(final TriggerSyncArgs input) {
@Override
public ListenableFuture<OperationResult> apply(final Optional<ReportedLsp> rep) {
- final Lsp reportedLsp = validateReportedLsp(rep, this.input);
+ final Lsp reportedLsp = validateReportedLsp(rep, input);
if (reportedLsp == null || !rep.isPresent()) {
return OperationResults.createUnsent(PCEPErrors.UNKNOWN_PLSP_ID).future();
}
if (!staleLsp.getPath().isEmpty()) {
final Path1 path1 = staleLsp.getPath().values().iterator().next().augmentation(Path1.class);
if (path1 != null) {
- PCEPTopologySessionListener.this.staleLsps.add(path1.getLsp().getPlspId());
+ staleLsps.add(path1.getLsp().getPlspId());
}
}
updatePccState(PccSyncState.PcepTriggeredResync);
}
private Message createPcepUpd(final Srp srp, final Lsp lsp) {
- final UpdatesBuilder rb = new UpdatesBuilder();
- rb.setSrp(srp);
- rb.setLsp(lsp);
- final PathBuilder pb = new PathBuilder();
- rb.setPath(pb.build());
- final PcupdMessageBuilder ub = new PcupdMessageBuilder(MESSAGE_HEADER);
- ub.setUpdates(Collections.singletonList(rb.build()));
- return new PcupdBuilder().setPcupdMessage(ub.build()).build();
+ return new PcupdBuilder()
+ .setPcupdMessage(new PcupdMessageBuilder(MESSAGE_HEADER)
+ .setUpdates(List.of(new UpdatesBuilder()
+ .setSrp(srp)
+ .setLsp(lsp)
+ .setPath(new PathBuilder().build())
+ .build()))
+ .build())
+ .build();
}
}
@Override
public ListenableFuture<OperationResult> apply(final Optional<ReportedLsp> rep) {
if (rep.isPresent()) {
- LOG.debug("Node {} already contains lsp {} at {}", this.input.getNode(), this.input.getName(),
- this.lsp);
+ LOG.debug("Node {} already contains lsp {} at {}", input.getNode(), input.getName(), lsp);
return OperationResults.createUnsent(PCEPErrors.USED_SYMBOLIC_PATH_NAME).future();
}
- if (!PCEPTopologySessionListener.this.initiationCapability.get()) {
+ if (!isInitiationCapability()) {
return OperationResults.createUnsent(PCEPErrors.CAPABILITY_NOT_SUPPORTED).future();
}
// Build the request
final RequestsBuilder rb = new RequestsBuilder();
- final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120
- .add.lsp.args.Arguments args = this.input.getArguments();
+ final var args = input.getArguments();
final Arguments2 args2 = args.augmentation(Arguments2.class);
final Lsp inputLsp = args2 != null ? args2.getLsp() : null;
if (inputLsp == null) {
return OperationResults.createUnsent(PCEPErrors.LSP_MISSING).future();
}
- rb.fieldsFrom(this.input.getArguments());
+ rb.fieldsFrom(input.getArguments());
- /* Call Path Computation if an ERO was not provided */
boolean segmentRouting = !PSTUtil.isDefaultPST(args2.getPathSetupType());
- if (rb.getEro() == null
- || rb.getEro().getSubobject() == null
- || rb.getEro().getSubobject().size() == 0) {
+ /* Call Path Computation if an ERO was not provided */
+ if (rb.getEro() == null || rb.getEro().nonnullSubobject().isEmpty()) {
/* Get a Path Computation to compute the Path from the Arguments */
+ // TODO: Adjust Junit Test to avoid this test
+ if (pceServerProvider == null) {
+ return OperationResults.createUnsent(PCEPErrors.ERO_MISSING).future();
+ }
PathComputation pathComputation = pceServerProvider.getPathComputation();
if (pathComputation == null) {
return OperationResults.createUnsent(PCEPErrors.ERO_MISSING).future();
}
- rb.setEro(pathComputation.computeEro(args.getEndpointsObj(), args.getBandwidth(), args.getClassType(),
- args.getMetrics(), segmentRouting));
+ rb.setEro(pathComputation.computeEro(args.getEndpointsObj(), args.getBandwidth(),
+ args.getClassType(), args.getMetrics(), args.getXro(), args.getIro(), segmentRouting));
}
final TlvsBuilder tlvsBuilder;
tlvsBuilder = new TlvsBuilder();
}
tlvsBuilder.setSymbolicPathName(
- new SymbolicPathNameBuilder().setPathName(new SymbolicPathName(this.input.getName()
+ new SymbolicPathNameBuilder().setPathName(new SymbolicPathName(input.getName()
.getBytes(StandardCharsets.UTF_8))).build());
final SrpBuilder srpBuilder = new SrpBuilder()
rb.setSrp(srpBuilder.build());
rb.setLsp(new LspBuilder()
- .setAdministrative(inputLsp.isAdministrative())
- .setDelegate(inputLsp.isDelegate())
+ .setAdministrative(inputLsp.getAdministrative())
+ .setDelegate(inputLsp.getDelegate())
.setPlspId(PLSPID_ZERO)
.setTlvs(tlvsBuilder.build())
.build());
// Send the message
return sendMessage(new PcinitiateBuilder()
.setPcinitiateMessage(new PcinitiateMessageBuilder(MESSAGE_HEADER)
- .setRequests(Collections.singletonList(rb.build()))
+ .setRequests(List.of(rb.build()))
.build())
.build(),
- rb.getSrp().getOperationId(), this.input.getArguments().getMetadata());
+ rb.getSrp().getOperationId(), input.getArguments().getMetadata());
}
}
@Override
public ListenableFuture<OperationResult> apply(final Optional<ReportedLsp> rep) {
- final Lsp reportedLsp = validateReportedLsp(rep, this.input);
+ final Lsp reportedLsp = validateReportedLsp(rep, input);
if (reportedLsp == null) {
return OperationResults.createUnsent(PCEPErrors.UNKNOWN_PLSP_ID).future();
}
// create mandatory objects
- final Arguments3 args = this.input.getArguments().augmentation(Arguments3.class);
+ final Arguments3 args = input.getArguments().augmentation(Arguments3.class);
final SrpBuilder srpBuilder = new SrpBuilder();
srpBuilder.setOperationId(nextRequest());
srpBuilder.setProcessingRule(Boolean.TRUE);
final Lsp inputLsp = args != null ? args.getLsp() : null;
final LspBuilder lspBuilder = new LspBuilder().setPlspId(reportedLsp.getPlspId());
if (inputLsp != null) {
- lspBuilder.setDelegate(inputLsp.isDelegate() != null && inputLsp.isDelegate())
+ lspBuilder.setDelegate(Boolean.TRUE.equals(inputLsp.getDelegate()))
.setTlvs(inputLsp.getTlvs())
- .setAdministrative(inputLsp.isAdministrative() != null && inputLsp.isAdministrative());
+ .setAdministrative(Boolean.TRUE.equals(inputLsp.getAdministrative()));
}
- return redelegate(reportedLsp, srp, lspBuilder.build(), this.input);
+ return redelegate(reportedLsp, srp, lspBuilder.build(), input);
}
}
private static Pcerr createErrorMsg(@NonNull final PCEPErrors pcepErrors, final Uint32 reqID) {
return new PcerrBuilder()
- .setPcerrMessage(new PcerrMessageBuilder()
- .setErrorType(new RequestCaseBuilder()
- .setRequest(new RequestBuilder()
- .setRps(Collections.singletonList(new RpsBuilder()
- .setRp(new RpBuilder()
- .setProcessingRule(false)
- .setIgnore(false)
- .setRequestId(new RequestId(reqID))
- .build())
- .build()))
- .build())
+ .setPcerrMessage(new PcerrMessageBuilder()
+ .setErrorType(new RequestCaseBuilder()
+ .setRequest(new RequestBuilder()
+ .setRps(List.of(new RpsBuilder()
+ .setRp(new RpBuilder()
+ .setProcessingRule(false)
+ .setIgnore(false)
+ .setRequestId(new RequestId(reqID))
+ .build())
+ .build()))
.build())
- .setErrors(Collections.singletonList(new ErrorsBuilder()
- .setErrorObject(new ErrorObjectBuilder()
- .setType(pcepErrors.getErrorType())
- .setValue(pcepErrors.getErrorValue())
- .build())
- .build()))
.build())
- .build();
+ .setErrors(List.of(new ErrorsBuilder()
+ .setErrorObject(new ErrorObjectBuilder()
+ .setType(pcepErrors.getErrorType())
+ .setValue(pcepErrors.getErrorValue())
+ .build())
+ .build()))
+ .build())
+ .build();
}
}
Code Review / bgpcep.git / blobdiff