import io.netty.channel.Channel;
import io.netty.util.concurrent.Promise;
+import java.util.List;
import org.eclipse.jdt.annotation.NonNull;
/**
@NonNull SessionNegotiator getSessionNegotiator(
@NonNull PCEPSessionNegotiatorFactoryDependencies sessionNegotiatorDependencies,
@NonNull Channel channel, @NonNull Promise<PCEPSession> promise);
+
+ /**
+ * Returns list containing PCEP Capabilities.
+ *
+ * @return PCEPCapabilities
+ */
+ @Deprecated(forRemoval = true)
+ @NonNull List<PCEPCapability> getCapabilities();
}
+++ /dev/null
-/*
- * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * 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.protocol.pcep;
-
-import java.net.InetSocketAddress;
-import java.util.List;
-import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.open.object.Open;
-import org.opendaylight.yangtools.yang.common.Uint8;
-
-/**
- * Factory for generating PCEP Session proposals. Used by a server.
- */
-public interface PCEPSessionProposalFactory {
- /**
- * Creates Open with session proposal.
- *
- * @param address serves as constraint, so that factory is able to return different proposals for different
- * addresses
- * @param sessionId is used for creation of PCEPOpenObject
- * @param peerProposal for including information from peer to our Open message
- * @return specific session proposal
- */
- @NonNull Open getSessionProposal(@NonNull InetSocketAddress address, @NonNull Uint8 sessionId,
- @Nullable PCEPPeerProposal peerProposal);
-
- /**
- * Returns list containing PCEP Capabilities.
- *
- * @return PCEPCapabilities
- */
- @NonNull List<PCEPCapability> getCapabilities();
-}
+++ /dev/null
-/*
- * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * 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.protocol.pcep.impl;
-
-import static java.util.Objects.requireNonNull;
-
-import java.net.InetSocketAddress;
-import java.util.List;
-import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.protocol.pcep.PCEPCapability;
-import org.opendaylight.protocol.pcep.PCEPPeerProposal;
-import org.opendaylight.protocol.pcep.PCEPSessionProposalFactory;
-import org.opendaylight.protocol.pcep.PCEPTimerProposal;
-import org.opendaylight.protocol.pcep.impl.spi.Util;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.config.rev230112.PcepSessionTimers;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.open.object.Open;
-import org.opendaylight.yangtools.yang.common.Uint8;
-
-public final class BasePCEPSessionProposalFactory implements PCEPSessionProposalFactory {
- private final @NonNull List<PCEPCapability> capabilities;
- private final @NonNull PCEPTimerProposal timers;
-
- public BasePCEPSessionProposalFactory(final PCEPTimerProposal timers, final List<PCEPCapability> capabilities) {
- this.timers = requireNonNull(timers);
- this.capabilities = requireNonNull(capabilities);
- }
-
- public BasePCEPSessionProposalFactory(final PcepSessionTimers timers, final List<PCEPCapability> capabilities) {
- this(new PCEPTimerProposal(timers), capabilities);
- }
-
- public BasePCEPSessionProposalFactory(final Uint8 deadTimer, final Uint8 keepAlive,
- final List<PCEPCapability> capabilities) {
- this(new PCEPTimerProposal(keepAlive, deadTimer), capabilities);
- }
-
- @Override
- public Open getSessionProposal(final InetSocketAddress address, final Uint8 sessionId,
- final PCEPPeerProposal peerProposal) {
- return Util.createOpenObject(address, sessionId, timers, capabilities, peerProposal);
- }
-
- @Override
- public List<PCEPCapability> getCapabilities() {
- return capabilities;
- }
-}
import io.netty.channel.Channel;
import io.netty.util.concurrent.Promise;
import java.net.InetSocketAddress;
+import java.util.List;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.protocol.pcep.PCEPCapability;
import org.opendaylight.protocol.pcep.PCEPSession;
import org.opendaylight.protocol.pcep.PCEPSessionNegotiatorFactoryDependencies;
-import org.opendaylight.protocol.pcep.PCEPSessionProposalFactory;
+import org.opendaylight.protocol.pcep.PCEPTimerProposal;
+import org.opendaylight.protocol.pcep.impl.spi.Util;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.pcep.app.config.rev160707.PcepDispatcherConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.config.rev230112.PcepSessionErrorPolicy;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.config.rev230112.PcepSessionTimers;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.config.rev230112.PcepSessionTls;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.open.object.Open;
import org.opendaylight.yangtools.yang.common.Uint8;
public final class DefaultPCEPSessionNegotiatorFactory extends AbstractPCEPSessionNegotiatorFactory {
+ private final PCEPTimerProposal timers;
+ private final @NonNull List<PCEPCapability> capabilities;
private final PcepSessionErrorPolicy errorPolicy;
- private final PCEPSessionProposalFactory spf;
private final PcepSessionTls tlsConfiguration;
- public DefaultPCEPSessionNegotiatorFactory(final PCEPSessionProposalFactory spf,
+ public DefaultPCEPSessionNegotiatorFactory(final PcepSessionTimers timers, final List<PCEPCapability> capabilities,
final PcepSessionErrorPolicy errorPolicy) {
- this(spf, errorPolicy, errorPolicy instanceof PcepDispatcherConfig dc ? dc.getTls() : null);
+ this(timers, capabilities, errorPolicy, errorPolicy instanceof PcepDispatcherConfig dc ? dc.getTls() : null);
}
- public DefaultPCEPSessionNegotiatorFactory(final PCEPSessionProposalFactory spf,
+ public DefaultPCEPSessionNegotiatorFactory(final PcepSessionTimers timers, final List<PCEPCapability> capabilities,
final PcepSessionErrorPolicy errorPolicy, final PcepSessionTls tlsConfiguration) {
- this.spf = requireNonNull(spf);
+ this(new PCEPTimerProposal(timers), capabilities, errorPolicy, tlsConfiguration);
+ }
+
+ public DefaultPCEPSessionNegotiatorFactory(final PCEPTimerProposal timers, final List<PCEPCapability> capabilities,
+ final PcepSessionErrorPolicy errorPolicy, final PcepSessionTls tlsConfiguration) {
+ this.timers = requireNonNull(timers);
+ this.capabilities = requireNonNull(capabilities);
this.errorPolicy = requireNonNull(errorPolicy);
this.tlsConfiguration = tlsConfiguration;
}
+ @Deprecated(forRemoval = true)
+ @Override
+ public List<PCEPCapability> getCapabilities() {
+ return capabilities;
+ }
+
@Override
protected AbstractPCEPSessionNegotiator createNegotiator(
final PCEPSessionNegotiatorFactoryDependencies sessionNegotiatorDependencies,
final Channel channel,
final Uint8 sessionId) {
- final Open proposal = spf.getSessionProposal((InetSocketAddress) channel.remoteAddress(), sessionId,
- sessionNegotiatorDependencies.getPeerProposal());
+ final Open proposal = Util.createOpenObject((InetSocketAddress) channel.remoteAddress(), sessionId, timers,
+ capabilities, sessionNegotiatorDependencies.getPeerProposal());
+
return new DefaultPCEPSessionNegotiator(
promise,
channel,
<odl:clustered-app-config id="pcepSessionConfig"
binding-class="org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.pcep.app.config.rev160707.PcepSessionConfig"/>
- <bean id="sessionProposalFactory" class="org.opendaylight.protocol.pcep.impl.BasePCEPSessionProposalFactory">
- <argument ref="pcepSessionConfig"/>
- <argument ref="pcepCapabilities"/>
- </bean>
-
- <service ref="sessionProposalFactory" interface="org.opendaylight.protocol.pcep.PCEPSessionProposalFactory"/>
-
<odl:clustered-app-config id="pcepDispatcherConfig"
binding-class="org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.pcep.app.config.rev160707.PcepDispatcherConfig"/>
<bean id="pcepSessionNegotiatorFactory" class="org.opendaylight.protocol.pcep.impl.DefaultPCEPSessionNegotiatorFactory">
- <argument ref="sessionProposalFactory"/>
+ <argument ref="pcepSessionConfig"/>
+ <argument ref="pcepCapabilities"/>
<argument ref="pcepDispatcherConfig"/>
</bean>
import org.opendaylight.protocol.pcep.PCEPSessionListenerFactory;
import org.opendaylight.protocol.pcep.PCEPSessionNegotiatorFactory;
import org.opendaylight.protocol.pcep.PCEPSessionNegotiatorFactoryDependencies;
+import org.opendaylight.protocol.pcep.PCEPTimerProposal;
import org.opendaylight.protocol.pcep.spi.pojo.DefaultPCEPExtensionConsumerContext;
import org.opendaylight.protocol.util.InetSocketAddressUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.config.rev230112.PcepSessionErrorPolicy;
public void setUp() {
doReturn(Uint16.ZERO).when(errorPolicy).requireMaxUnknownMessages();
- final var sessionProposal = new BasePCEPSessionProposalFactory(DEAD_TIMER, KEEP_ALIVE, List.of());
msgReg = new DefaultPCEPExtensionConsumerContext().getMessageHandlerRegistry();
- negotiatorFactory = new DefaultPCEPSessionNegotiatorFactory(sessionProposal, errorPolicy);
+ negotiatorFactory = new DefaultPCEPSessionNegotiatorFactory(new PCEPTimerProposal(KEEP_ALIVE, DEAD_TIMER),
+ List.of(), errorPolicy, null);
dispatcher = new PCEPDispatcherImpl();
import org.opendaylight.protocol.pcep.MessageRegistry;
import org.opendaylight.protocol.pcep.PCEPCapability;
import org.opendaylight.protocol.pcep.PCEPSessionNegotiatorFactory;
-import org.opendaylight.protocol.pcep.impl.BasePCEPSessionProposalFactory;
+import org.opendaylight.protocol.pcep.PCEPTimerProposal;
import org.opendaylight.protocol.pcep.impl.DefaultPCEPSessionNegotiatorFactory;
import org.opendaylight.protocol.pcep.pcc.mock.api.PCCTunnelManager;
import org.opendaylight.protocol.pcep.pcc.mock.protocol.MockPcepSessionErrorPolicy;
}
private PCEPSessionNegotiatorFactory getSessionNegotiatorFactory() {
- return new DefaultPCEPSessionNegotiatorFactory(new BasePCEPSessionProposalFactory(deadTimer,
- keepAlive, List.of(pcepCapabilities)), MockPcepSessionErrorPolicy.ZERO);
+ return new DefaultPCEPSessionNegotiatorFactory(new PCEPTimerProposal(keepAlive, deadTimer),
+ List.of(pcepCapabilities), MockPcepSessionErrorPolicy.ZERO, null);
}
}
import org.opendaylight.protocol.pcep.MessageRegistry;
import org.opendaylight.protocol.pcep.PCEPSession;
import org.opendaylight.protocol.pcep.PCEPSessionNegotiatorFactoryDependencies;
-import org.opendaylight.protocol.pcep.PCEPSessionProposalFactory;
-import org.opendaylight.protocol.pcep.impl.BasePCEPSessionProposalFactory;
+import org.opendaylight.protocol.pcep.PCEPTimerProposal;
import org.opendaylight.protocol.pcep.impl.DefaultPCEPSessionNegotiatorFactory;
import org.opendaylight.protocol.pcep.impl.PCEPDispatcherImpl;
import org.opendaylight.protocol.pcep.pcc.mock.protocol.MockPcepSessionErrorPolicy;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class PCCDispatcherImplTest {
-
- private static final PCEPSessionProposalFactory PROPOSAL = new BasePCEPSessionProposalFactory(Uint8.TEN,
- Uint8.valueOf(40), List.of());
- private final DefaultPCEPSessionNegotiatorFactory nf = new DefaultPCEPSessionNegotiatorFactory(PROPOSAL,
- MockPcepSessionErrorPolicy.ZERO);
+ private final DefaultPCEPSessionNegotiatorFactory nf = new DefaultPCEPSessionNegotiatorFactory(
+ new PCEPTimerProposal(Uint8.TEN, Uint8.valueOf(40)), List.of(), MockPcepSessionErrorPolicy.ZERO, null);
private PCCDispatcherImpl dispatcher;
private PCEPDispatcherImpl pcepDispatcher;
import org.opendaylight.protocol.pcep.PCEPSessionListenerFactory;
import org.opendaylight.protocol.pcep.PCEPSessionNegotiatorFactory;
import org.opendaylight.protocol.pcep.PCEPSessionNegotiatorFactoryDependencies;
+import org.opendaylight.protocol.pcep.PCEPTimerProposal;
import org.opendaylight.protocol.pcep.ietf.stateful.StatefulActivator;
-import org.opendaylight.protocol.pcep.impl.BasePCEPSessionProposalFactory;
import org.opendaylight.protocol.pcep.impl.DefaultPCEPSessionNegotiatorFactory;
import org.opendaylight.protocol.pcep.impl.PCEPDispatcherImpl;
import org.opendaylight.protocol.pcep.pcc.mock.api.PCCTunnelManager;
@Before
public void setUp() {
- negotiatorFactory = new DefaultPCEPSessionNegotiatorFactory(
- new BasePCEPSessionProposalFactory(DEAD_TIMER, KEEP_ALIVE, getCapabilities()),
- MockPcepSessionErrorPolicy.ZERO);
+ negotiatorFactory = getSessionNegotiatorFactory();
ServiceLoader.load(PCEPExtensionProviderActivator.class).forEach(act -> act.start(extensionProvider));
}
private PCEPSessionNegotiatorFactory getSessionNegotiatorFactory() {
- return new DefaultPCEPSessionNegotiatorFactory(new BasePCEPSessionProposalFactory(DEAD_TIMER, KEEP_ALIVE,
- getCapabilities()), MockPcepSessionErrorPolicy.ZERO);
+ return new DefaultPCEPSessionNegotiatorFactory(new PCEPTimerProposal(KEEP_ALIVE, DEAD_TIMER),
+ getCapabilities(), MockPcepSessionErrorPolicy.ZERO, null);
}
TestingSessionListener getListener(final TestingSessionListenerFactory factory) {
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.UnknownHostException;
-import java.util.ArrayList;
import java.util.List;
import java.util.ServiceLoader;
import java.util.concurrent.ExecutionException;
import org.opendaylight.protocol.concepts.KeyMapping;
import org.opendaylight.protocol.pcep.MessageRegistry;
-import org.opendaylight.protocol.pcep.PCEPCapability;
-import org.opendaylight.protocol.pcep.PCEPSessionProposalFactory;
+import org.opendaylight.protocol.pcep.PCEPTimerProposal;
import org.opendaylight.protocol.pcep.ietf.stateful.PCEPStatefulCapability;
-import org.opendaylight.protocol.pcep.impl.BasePCEPSessionProposalFactory;
import org.opendaylight.protocol.pcep.impl.DefaultPCEPSessionNegotiatorFactory;
import org.opendaylight.protocol.pcep.impl.PCEPDispatcherImpl;
import org.opendaylight.protocol.pcep.spi.PCEPExtensionConsumerContext;
LOG.warn("WARNING: The value of DeadTimer should be 4 times the value of KeepAlive.");
}
- final List<PCEPCapability> caps = new ArrayList<>();
- caps.add(new PCEPStatefulCapability(stateful, active, instant, false, false, false, false));
- final PCEPSessionProposalFactory spf = new BasePCEPSessionProposalFactory(deadTimerValue, keepAliveValue, caps);
-
final MessageRegistry handlerRegistry = ServiceLoader.load(PCEPExtensionConsumerContext.class).findFirst()
.orElseThrow()
.getMessageHandlerRegistry();
final PCEPDispatcherImpl dispatcher = new PCEPDispatcherImpl();
dispatcher.createServer(address, KeyMapping.of(), handlerRegistry,
- new DefaultPCEPSessionNegotiatorFactory(spf, ERROR_POLICY), new TestToolPCEPNegotiatorDependencies()).get();
+ new DefaultPCEPSessionNegotiatorFactory(new PCEPTimerProposal(keepAliveValue, deadTimerValue),
+ List.of(new PCEPStatefulCapability(stateful, active, instant, false, false, false, false)),
+ ERROR_POLICY, null), new TestToolPCEPNegotiatorDependencies()).get();
}
}
import java.util.List;
import java.util.concurrent.ExecutionException;
import org.opendaylight.protocol.concepts.KeyMapping;
-import org.opendaylight.protocol.pcep.impl.BasePCEPSessionProposalFactory;
+import org.opendaylight.protocol.pcep.PCEPTimerProposal;
import org.opendaylight.protocol.pcep.impl.DefaultPCEPSessionNegotiatorFactory;
import org.opendaylight.protocol.pcep.pcc.mock.protocol.PCCDispatcherImpl;
import org.opendaylight.protocol.pcep.spi.pojo.DefaultPCEPExtensionConsumerContext;
public static void main(final String[] args) throws InterruptedException, ExecutionException {
checkArgument(args.length > 0, "Host and port of server must be provided.");
- final var proposal = new BasePCEPSessionProposalFactory(Uint8.valueOf(120), Uint8.valueOf(30), List.of());
- final var snf = new DefaultPCEPSessionNegotiatorFactory(proposal, ERROR_POLICY);
+ final var snf = new DefaultPCEPSessionNegotiatorFactory(
+ new PCEPTimerProposal(Uint8.valueOf(30), Uint8.valueOf(120)), List.of(), ERROR_POLICY, null);
final var serverHostAndPort = HostAndPort.fromString(args[0]);
final var serverAddr = new InetSocketAddress(serverHostAndPort.getHost(),
serverHostAndPort.getPortOrDefault(12345));
synchronized void updateConfiguration(final @Nullable PCEPTopologyConfiguration newConfiguration) {
// FIXME: BGPCEP-960: this check should be a one-time thing in PCEPTopologyTracker startup once we have OSGi DS
- final var effectiveConfig = dependencies.getPCEPSessionProposalFactory().getCapabilities().stream()
+ final var effectiveConfig = dependencies.getPCEPSessionNegotiatorFactory().getCapabilities().stream()
.anyMatch(PCEPCapability::isStateful) ? newConfiguration : null;
applyConfiguration(effectiveConfig);
import org.opendaylight.protocol.pcep.MessageRegistry;
import org.opendaylight.protocol.pcep.PCEPDispatcher;
import org.opendaylight.protocol.pcep.PCEPSessionNegotiatorFactory;
-import org.opendaylight.protocol.pcep.PCEPSessionProposalFactory;
/**
* Provides required dependencies for PCEPTopologyProviderProvider instantiation.
*/
MessageRegistry getMessageRegistry();
- /**
- * Returns a PCEPSessionProposalFactory.
- *
- * @return session factory
- */
- PCEPSessionProposalFactory getPCEPSessionProposalFactory();
-
/**
* PCEP Session Negotiator Factory.
*
import org.opendaylight.protocol.pcep.MessageRegistry;
import org.opendaylight.protocol.pcep.PCEPDispatcher;
import org.opendaylight.protocol.pcep.PCEPSessionNegotiatorFactory;
-import org.opendaylight.protocol.pcep.PCEPSessionProposalFactory;
import org.opendaylight.protocol.pcep.spi.PCEPExtensionConsumerContext;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321.PcepTopologyStatsRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev220730.TopologyTypes1;
final @NonNull InstructionSchedulerFactory instructionSchedulerFactory;
final @NonNull ClusterSingletonServiceProvider singletonService;
private final @NonNull PCEPSessionNegotiatorFactory sessionNegotiatorFactory;
- private final @NonNull PCEPSessionProposalFactory sessionProposalFactory;
private final @NonNull RpcProviderService rpcProviderRegistry;
private final @NonNull PceServerProvider pceServerProvider;
private final @NonNull MessageRegistry messageRegistry;
public PCEPTopologyTracker(final DataBroker dataBroker, final ClusterSingletonServiceProvider singletonService,
final RpcProviderService rpcProviderRegistry, final PCEPExtensionConsumerContext extensions,
- final PCEPSessionProposalFactory sessionProposalFactory,
final PCEPSessionNegotiatorFactory sessionNegotiatorFactory,
final PCEPDispatcher pcepDispatcher, final InstructionSchedulerFactory instructionSchedulerFactory,
final PceServerProvider pceServerProvider) {
this.singletonService = requireNonNull(singletonService);
this.rpcProviderRegistry = requireNonNull(rpcProviderRegistry);
messageRegistry = extensions.getMessageHandlerRegistry();
- this.sessionProposalFactory = requireNonNull(sessionProposalFactory);
this.sessionNegotiatorFactory = requireNonNull(sessionNegotiatorFactory);
this.pcepDispatcher = requireNonNull(pcepDispatcher);
this.instructionSchedulerFactory = requireNonNull(instructionSchedulerFactory);
return messageRegistry;
}
- @Override
- public PCEPSessionProposalFactory getPCEPSessionProposalFactory() {
- return sessionProposalFactory;
- }
-
@Override
public PCEPSessionNegotiatorFactory getPCEPSessionNegotiatorFactory() {
return sessionNegotiatorFactory;
<reference id="dataBroker" interface="org.opendaylight.mdsal.binding.api.DataBroker"/>
<reference id="rpcProviderService" interface="org.opendaylight.mdsal.binding.api.RpcProviderService"/>
<reference id="pcepExtensionContext" interface="org.opendaylight.protocol.pcep.spi.PCEPExtensionConsumerContext"/>
- <reference id="sessionProposalFactory" interface="org.opendaylight.protocol.pcep.PCEPSessionProposalFactory"/>
<reference id="sessionNegotiatorFactory" interface="org.opendaylight.protocol.pcep.PCEPSessionNegotiatorFactory"/>
<reference id="pcepDispatcher" interface="org.opendaylight.protocol.pcep.PCEPDispatcher"/>
<reference id="clusterSingletonServiceProvider"
<argument ref="clusterSingletonServiceProvider"/>
<argument ref="rpcProviderService"/>
<argument ref="pcepExtensionContext"/>
- <argument ref="sessionProposalFactory"/>
<argument ref="sessionNegotiatorFactory"/>
<argument ref="pcepDispatcher"/>
<argument ref="intructionFactory"/>