<artifactId>learning-switch</artifactId>
<packaging>bundle</packaging>
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.felix</groupId>
- <artifactId>maven-bundle-plugin</artifactId>
- <extensions>true</extensions>
- </plugin>
- </plugins>
- </build>
<dependencies>
<dependency>
- <groupId>org.opendaylight.openflowplugin.model</groupId>
- <artifactId>model-flow-base</artifactId>
+ <groupId>com.guicedee.services</groupId>
+ <artifactId>javax.inject</artifactId>
+ <optional>true</optional>
</dependency>
<dependency>
- <groupId>org.opendaylight.openflowplugin.model</groupId>
- <artifactId>model-flow-service</artifactId>
+ <groupId>jakarta.annotation</groupId>
+ <artifactId>jakarta.annotation-api</artifactId>
+ <optional>true</optional>
</dependency>
<dependency>
- <groupId>org.opendaylight.openflowplugin.model</groupId>
- <artifactId>model-inventory</artifactId>
+ <groupId>org.opendaylight.infrautils</groupId>
+ <artifactId>infrautils-util</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>openflowplugin-api</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.infrautils</groupId>
- <artifactId>infrautils-util</artifactId>
+ <groupId>org.opendaylight.openflowplugin.model</groupId>
+ <artifactId>model-flow-base</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.openflowplugin.model</groupId>
+ <artifactId>model-flow-service</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.openflowplugin.model</groupId>
+ <artifactId>model-inventory</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.osgi</groupId>
+ <artifactId>org.osgi.service.component.annotations</artifactId>
</dependency>
</dependencies>
</project>
*/
package org.opendaylight.openflowplugin.learningswitch;
+import static java.util.Objects.requireNonNull;
+
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
-import java.util.Objects;
import java.util.Set;
import java.util.concurrent.atomic.AtomicLong;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceived;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacket;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInputBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint16;
* Simple Learning Switch implementation which does mac learning for one switch.
*/
public class LearningSwitchHandlerSimpleImpl implements LearningSwitchHandler, Listener<PacketReceived> {
-
private static final Logger LOG = LoggerFactory.getLogger(LearningSwitchHandlerSimpleImpl.class);
private static final byte[] ETH_TYPE_IPV4 = new byte[] { 0x08, 0x00 };
private static final Uint16 DIRECT_FLOW_PRIORITY = Uint16.valueOf(512);
private final DataTreeChangeListenerRegistrationHolder registrationPublisher;
private final FlowCommitWrapper dataStoreAccessor;
- private final PacketProcessingService packetProcessingService;
+ private final TransmitPacket transmitPacket;
private volatile boolean isLearning = false;
private Map<MacAddress, NodeConnectorRef> mac2portMapping;
private final Set<String> coveredMacPaths = new HashSet<>();
- public LearningSwitchHandlerSimpleImpl(@NonNull FlowCommitWrapper dataStoreAccessor,
- @NonNull PacketProcessingService packetProcessingService,
- @Nullable DataTreeChangeListenerRegistrationHolder registrationPublisher) {
- this.dataStoreAccessor = Objects.requireNonNull(dataStoreAccessor);
- this.packetProcessingService = Objects.requireNonNull(packetProcessingService);
+ public LearningSwitchHandlerSimpleImpl(final @NonNull FlowCommitWrapper dataStoreAccessor,
+ final @NonNull TransmitPacket transmitPacket,
+ final @Nullable DataTreeChangeListenerRegistrationHolder registrationPublisher) {
+ this.dataStoreAccessor = requireNonNull(dataStoreAccessor);
+ this.transmitPacket = requireNonNull(transmitPacket);
this.registrationPublisher = registrationPublisher;
}
@Override
- public synchronized void onSwitchAppeared(InstanceIdentifier<Table> appearedTablePath) {
+ public synchronized void onSwitchAppeared(
final InstanceIdentifier<Table> appearedTablePath) {
if (isLearning) {
LOG.debug("already learning a node, skipping {}", nodeId.getValue());
return;
}
@Override
- public void onNotification(PacketReceived notification) {
+ public void onNotification(final PacketReceived notification) {
if (!isLearning) {
// ignoring packets - this should not happen
return;
// non IPv4 package
flood(notification.getPayload(), notification.getIngress());
}
-
}
- private void addBridgeFlow(MacAddress srcMac, MacAddress dstMac, NodeConnectorRef destNodeConnector) {
+ private void addBridgeFlow(final MacAddress srcMac, final MacAddress dstMac,
+ final NodeConnectorRef destNodeConnector) {
synchronized (coveredMacPaths) {
String macPath = srcMac.toString() + dstMac.toString();
if (!coveredMacPaths.contains(macPath)) {
}
}
- private void flood(byte[] payload, NodeConnectorRef ingress) {
+ private void flood(final byte[] payload, final NodeConnectorRef ingress) {
NodeConnectorKey nodeConnectorKey = new NodeConnectorKey(nodeConnectorId("0xfffffffb"));
InstanceIdentifier<?> nodeConnectorPath = InstanceIdentifierUtils.createNodeConnectorPath(
nodePath, nodeConnectorKey);
sendPacketOut(payload, ingress, egressConnectorRef);
}
- private NodeConnectorId nodeConnectorId(String connectorId) {
+ private NodeConnectorId nodeConnectorId(final String connectorId) {
NodeKey nodeKey = nodePath.firstKeyOf(Node.class);
StringBuilder stringId = new StringBuilder(nodeKey.getId().getValue()).append(":").append(connectorId);
return new NodeConnectorId(stringId.toString());
}
- private void sendPacketOut(byte[] payload, NodeConnectorRef ingress, NodeConnectorRef egress) {
- InstanceIdentifier<Node> egressNodePath = InstanceIdentifierUtils.getNodePath(egress.getValue());
- TransmitPacketInput input = new TransmitPacketInputBuilder()
- .setPayload(payload)
- .setNode(new NodeRef(egressNodePath))
- .setEgress(egress)
- .setIngress(ingress)
- .build();
- LoggingFutures.addErrorLogging(packetProcessingService.transmitPacket(input), LOG, "transmitPacket");
+ private void sendPacketOut(final byte[] payload, final NodeConnectorRef ingress, final NodeConnectorRef egress) {
+ LoggingFutures.addErrorLogging(transmitPacket.invoke(new TransmitPacketInputBuilder()
+ .setPayload(payload)
+ .setNode(new NodeRef(InstanceIdentifierUtils.getNodePath(egress.getValue())))
+ .setEgress(egress)
+ .setIngress(ingress)
+ .build()), LOG, "transmitPacket");
}
}
+++ /dev/null
-/*
- * Copyright (c) 2014 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.openflowplugin.learningswitch;
-
-import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.binding.api.NotificationService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
-
-public interface LearningSwitchManager {
-
- /**
- * Stops this manager.
- */
- void stop();
-
- /**
- * Starts this manager.
- */
- void start();
-
- /**
- * Set's Data Broker dependency.
- *
- * <p>
- * Data Broker is used to access overall operational and configuration tree.
- *
- * <p>
- * In simple Learning Switch handler, data broker is used to listen
- * for changes in Openflow tables and to configure flows which will
- * be provisioned down to the Openflow switch.
- *
- * <p>
- * inject {@link DataBroker}
- */
- void setDataBroker(DataBroker data);
-
- /**
- * Set's Packet Processing dependency.
- *
- * <p>
- * Packet Processing service is used to send packet Out on Openflow switch.
- *
- * <p>
- * inject {@link PacketProcessingService}
- */
- void setPacketProcessingService(
- PacketProcessingService packetProcessingService);
-
- /**
- * Set's Notification service dependency.
- *
- * <p>
- * Notification service is used to register for listening packet-in notifications.
- *
- * <p>
- * inject {@link NotificationService}
- */
- void setNotificationService(NotificationService notificationService);
-}
import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceived;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacket;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
* corresponding MACs)</li>
* </ul>
*/
-public class LearningSwitchManagerSimpleImpl
- implements DataTreeChangeListenerRegistrationHolder, LearningSwitchManager {
+public final class LearningSwitchManagerSimpleImpl implements DataTreeChangeListenerRegistrationHolder, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(LearningSwitchManagerSimpleImpl.class);
- private NotificationService notificationService = null;
- private PacketProcessingService packetProcessingService;
- private DataBroker data = null;
- private Registration packetInRegistration = null;
- private ListenerRegistration<DataTreeChangeListener> dataTreeChangeListenerRegistration = null;
+ private final ListenerRegistration<DataTreeChangeListener> dataTreeChangeListenerRegistration;
+ private final Registration packetInRegistration;
- /**
- * Sets the NotificationService.
- *
- * @param notificationService the notificationService to set
- */
- @Override
- public void setNotificationService(final NotificationService notificationService) {
- this.notificationService = notificationService;
- }
-
- /**
- * Sets the PacketProcessingService.
- *
- * @param packetProcessingService the packetProcessingService to set
- */
- @Override
- public void setPacketProcessingService(
- final PacketProcessingService packetProcessingService) {
- this.packetProcessingService = packetProcessingService;
- }
-
- /**
- * Sets the DataBroker.
- */
- @Override
- public void setDataBroker(final DataBroker broker) {
- data = broker;
- }
-
- /**
- * Starts learning switch.
- */
- @Override
- public void start() {
+ public LearningSwitchManagerSimpleImpl(final DataBroker dataBroker, final NotificationService notificationService,
+ final RpcConsumerRegistry rpcService) {
LOG.debug("start() -->");
- FlowCommitWrapper dataStoreAccessor = new FlowCommitWrapperImpl(data);
+ final var dataStoreAccessor = new FlowCommitWrapperImpl(dataBroker);
- LearningSwitchHandlerSimpleImpl learningSwitchHandler = new LearningSwitchHandlerSimpleImpl(dataStoreAccessor,
- packetProcessingService, this);
+ final var learningSwitchHandler = new LearningSwitchHandlerSimpleImpl(dataStoreAccessor,
+ rpcService.getRpc(TransmitPacket.class), this);
packetInRegistration = notificationService.registerListener(PacketReceived.class, learningSwitchHandler);
- WakeupOnNode wakeupListener = new WakeupOnNode();
- wakeupListener.setLearningSwitchHandler(learningSwitchHandler);
- final InstanceIdentifier<Table> instanceIdentifier = InstanceIdentifier.create(Nodes.class)
+ dataTreeChangeListenerRegistration = dataBroker.registerDataTreeChangeListener(DataTreeIdentifier.create(
+ LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Nodes.class)
.child(Node.class)
.augmentation(FlowCapableNode.class)
- .child(Table.class);
- final DataTreeIdentifier<Table> dataTreeIdentifier =
- DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, instanceIdentifier);
- dataTreeChangeListenerRegistration = data.registerDataTreeChangeListener(dataTreeIdentifier, wakeupListener);
+ .child(Table.class)), new WakeupOnNode(learningSwitchHandler));
LOG.debug("start() <--");
}
- /**
- * Stops the learning switch.
- */
@Override
- public void stop() {
+ public void close() {
LOG.debug("stop() -->");
//TODO: remove flow (created in #start())
-
packetInRegistration.close();
-
dataTreeChangeListenerRegistration.close();
-
LOG.debug("stop() <--");
}
*/
package org.opendaylight.openflowplugin.learningswitch;
+import static java.util.Objects.requireNonNull;
+
import java.util.Collection;
import org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType;
import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
public class WakeupOnNode implements DataTreeChangeListener<Table> {
private static final Logger LOG = LoggerFactory.getLogger(WakeupOnNode.class);
- private LearningSwitchHandler learningSwitchHandler = null;
+ private final LearningSwitchHandler learningSwitchHandler;
+
+ public WakeupOnNode(final LearningSwitchHandler learningSwitchHandler) {
+ this.learningSwitchHandler = requireNonNull(learningSwitchHandler);
+ }
@Override
public void onDataTreeChanged(final Collection<DataTreeModification<Table>> modifications) {
}
}
}
-
- /**
- * Sets the LearningSwitchHandler.
- *
- * @param learningSwitchHandler the learningSwitchHandler to set
- */
- public void setLearningSwitchHandler(final LearningSwitchHandler learningSwitchHandler) {
- this.learningSwitchHandler = learningSwitchHandler;
- }
}
*/
package org.opendaylight.openflowplugin.learningswitch.multi;
+import javax.annotation.PreDestroy;
+import javax.inject.Inject;
+import javax.inject.Singleton;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.learningswitch.DataTreeChangeListenerRegistrationHolder;
-import org.opendaylight.openflowplugin.learningswitch.FlowCommitWrapper;
import org.opendaylight.openflowplugin.learningswitch.FlowCommitWrapperImpl;
-import org.opendaylight.openflowplugin.learningswitch.LearningSwitchManager;
import org.opendaylight.openflowplugin.learningswitch.WakeupOnNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceived;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacket;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.osgi.service.component.annotations.Activate;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Deactivate;
+import org.osgi.service.component.annotations.Reference;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* corresponding MACs)</li>
* </ul>
*/
-public class LearningSwitchManagerMultiImpl implements DataTreeChangeListenerRegistrationHolder, LearningSwitchManager {
+@Singleton
+@Component(service = { })
+public final class LearningSwitchManagerMultiImpl implements DataTreeChangeListenerRegistrationHolder, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(LearningSwitchManagerMultiImpl.class);
- private NotificationService notificationService = null;
- private PacketProcessingService packetProcessingService;
- private DataBroker data = null;
- private Registration packetInRegistration = null;
- private ListenerRegistration<DataTreeChangeListener> dataTreeChangeListenerRegistration = null;
+ private final ListenerRegistration<DataTreeChangeListener> dataTreeChangeListenerRegistration;
+ private final Registration packetInRegistration;
- /**
- * Sets the NotificationService.
- *
- * @param notificationService the notificationService to set
- */
- @Override
- public void setNotificationService(final NotificationService notificationService) {
- this.notificationService = notificationService;
- }
-
- /**
- * Sets the PacketProcessingService.
- *
- * @param packetProcessingService the packetProcessingService to set
- */
- @Override
- public void setPacketProcessingService(
- final PacketProcessingService packetProcessingService) {
- this.packetProcessingService = packetProcessingService;
- }
-
- /**
- * Sets the DataBroker.
- *
- * @param broker the data to set
- */
- @Override
- public void setDataBroker(final DataBroker broker) {
- data = broker;
- }
-
- /**
- * Starts learning switch.
- */
- @Override
- public void start() {
+ @Inject
+ @Activate
+ public LearningSwitchManagerMultiImpl(@Reference final DataBroker dataBroker,
+ @Reference final NotificationService notificationService, @Reference final RpcConsumerRegistry rpcService) {
LOG.debug("start() -->");
- FlowCommitWrapper dataStoreAccessor = new FlowCommitWrapperImpl(data);
+ final var dataStoreAccessor = new FlowCommitWrapperImpl(dataBroker);
- PacketInDispatcherImpl packetInDispatcher = new PacketInDispatcherImpl();
- MultipleLearningSwitchHandlerFacadeImpl learningSwitchHandler = new MultipleLearningSwitchHandlerFacadeImpl(
- dataStoreAccessor, packetProcessingService, packetInDispatcher);
+ final var packetInDispatcher = new PacketInDispatcherImpl();
+ final var learningSwitchHandler = new MultipleLearningSwitchHandlerFacadeImpl(
+ dataStoreAccessor, rpcService.getRpc(TransmitPacket.class), packetInDispatcher);
packetInRegistration = notificationService.registerListener(PacketReceived.class, packetInDispatcher);
- WakeupOnNode wakeupListener = new WakeupOnNode();
- wakeupListener.setLearningSwitchHandler(learningSwitchHandler);
- final InstanceIdentifier<Table> instanceIdentifier = InstanceIdentifier.create(Nodes.class)
+ dataTreeChangeListenerRegistration = dataBroker.registerDataTreeChangeListener(
+ DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Nodes.class)
.child(Node.class)
.augmentation(FlowCapableNode.class)
- .child(Table.class);
- final DataTreeIdentifier<Table> dataTreeIdentifier =
- DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, instanceIdentifier);
- dataTreeChangeListenerRegistration = data.registerDataTreeChangeListener(dataTreeIdentifier, wakeupListener);
+ .child(Table.class)),
+ new WakeupOnNode(learningSwitchHandler));
LOG.debug("start() <--");
}
- /**
- * Stops learning switch.
- */
+ @PreDestroy
+ @Deactivate
@Override
- public void stop() {
+ public void close() {
LOG.debug("stop() -->");
//TODO: remove flow (created in #start())
-
packetInRegistration.close();
-
dataTreeChangeListenerRegistration.close();
LOG.debug("stop() <--");
}
*/
package org.opendaylight.openflowplugin.learningswitch.multi;
-import java.util.Objects;
+import static java.util.Objects.requireNonNull;
+
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.learningswitch.FlowCommitWrapper;
import org.opendaylight.openflowplugin.learningswitch.InstanceIdentifierUtils;
import org.opendaylight.openflowplugin.learningswitch.LearningSwitchHandlerSimpleImpl;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacket;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class MultipleLearningSwitchHandlerFacadeImpl implements LearningSwitchHandler {
-
private static final Logger LOG = LoggerFactory.getLogger(MultipleLearningSwitchHandlerFacadeImpl.class);
- private final FlowCommitWrapper dataStoreAccessor;
- private final PacketProcessingService packetProcessingService;
+
+ private final @NonNull FlowCommitWrapper dataStoreAccessor;
+ private final @NonNull TransmitPacket transmitPacket;
private final PacketInDispatcherImpl packetInDispatcher;
- public MultipleLearningSwitchHandlerFacadeImpl(@NonNull FlowCommitWrapper dataStoreAccessor,
- @NonNull PacketProcessingService packetProcessingService,
- @NonNull PacketInDispatcherImpl packetInDispatcher) {
- this.dataStoreAccessor = Objects.requireNonNull(dataStoreAccessor);
- this.packetProcessingService = Objects.requireNonNull(packetProcessingService);
- this.packetInDispatcher = Objects.requireNonNull(packetInDispatcher);
+ public MultipleLearningSwitchHandlerFacadeImpl(final @NonNull FlowCommitWrapper dataStoreAccessor,
+ final @NonNull TransmitPacket transmitPacket, final @NonNull PacketInDispatcherImpl packetInDispatcher) {
+ this.dataStoreAccessor = requireNonNull(dataStoreAccessor);
+ this.transmitPacket = requireNonNull(transmitPacket);
+ this.packetInDispatcher = requireNonNull(packetInDispatcher);
}
-
@Override
- public synchronized void onSwitchAppeared(InstanceIdentifier<Table> appearedTablePath) {
+ public synchronized void onSwitchAppeared(
final InstanceIdentifier<Table> appearedTablePath) {
LOG.debug("expected table acquired, learning ..");
/**
*/
if (!packetInDispatcher.getHandlerMapping().containsKey(nodePath)) {
// delegate this node (owning appearedTable) to SimpleLearningSwitchHandler
- LearningSwitchHandlerSimpleImpl simpleLearningSwitch = new LearningSwitchHandlerSimpleImpl(
- dataStoreAccessor, packetProcessingService, null);
+ final var simpleLearningSwitch = new LearningSwitchHandlerSimpleImpl(dataStoreAccessor, transmitPacket,
+ null);
/**
* We propagate table event to newly instantiated instance of learning switch
+++ /dev/null
-<?xml version="1.0" encoding="UTF-8"?>
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0"
- xmlns:odl="http://opendaylight.org/xmlns/blueprint/v1.0.0"
- odl:use-default-for-reference-types="true">
-
- <reference id="dataBroker" interface="org.opendaylight.mdsal.binding.api.DataBroker"/>
- <reference id="notificationService" interface="org.opendaylight.mdsal.binding.api.NotificationService"/>
-
- <odl:rpc-service id="packetProcessingService" interface="org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService"/>
-
- <bean id="learningSwitch" class="org.opendaylight.openflowplugin.learningswitch.multi.LearningSwitchManagerMultiImpl"
- init-method="start" destroy-method="stop">
- <property name="dataBroker" ref="dataBroker"/>
- <property name="notificationService" ref="notificationService"/>
- <property name="packetProcessingService" ref="packetProcessingService"/>
- </bean>
-
-</blueprint>
Code Review / openflowplugin.git / commitdiff