import org.opendaylight.controller.sal.packet.IListenDataPacket; //导入依赖的package包/类
/**
 * Function that is called when configuration of the dependencies
 * is required.
 *
 * @param c dependency manager Component object, used for
 * configuring the dependencies exported and imported
 * @param imp Implementation class that is being configured,
 * needed as long as the same routine can configure multiple
 * implementations
 * @param containerName The containerName being configured, this allow
 * also optional per-container different behavior if needed, usually
 * should not be the case though.
 */
public void configureInstance(Component c, Object imp, String containerName) {
    if (imp.equals(ControllerServiceAdaptor.class)) {
        /*
         *  Export the fact that the Component exports the IListenDataPacket and
         *  IControllerService interfaces
         *  
         *  First create a dictionary and put the "salListenerName" property into it
         *  the "salListenerName" should be unique, and we use the package name here.
         */
        Dictionary<String, String> props = new Hashtable<String, String>();
        props.put("salListenerName", this.getClass().getPackage().getName());
        
        // Then set that we provide the IListenDataPacket and IControllerService interface with that property
        c.setInterface(new String[] {IListenDataPacket.class.getName(),
                    IControllerService.class.getName()}, props);

    } else if (imp.equals(OFSwitchAdaptor.class)) {
     // Export the fact that we export an IOFSwitch interface
        c.setInterface(IOFSwitch.class.getName(), null);
    }
}
 

import org.opendaylight.controller.sal.packet.IListenDataPacket; //导入依赖的package包/类
public void configureInstance(Component c, Object imp, String containerName) {
    log.trace("Configuring instance");

    if (imp.equals(DissectorHandler.class)) {
        // Define exported and used services for DissectorHandler component.

        Dictionary<String, Object> props = new Hashtable<String, Object>();
        props.put("salListenerName", "myDissectorHandler");

        // Export IListenDataPacket interface to receive packet-in events.
        c.setInterface(new String[] {IListenDataPacket.class.getName()}, props);

        // Need the DataPacketService for encoding, decoding, sending data packets
        c.add(createContainerServiceDependency(containerName).setService(
                IDataPacketService.class).setCallbacks(
                "setDataPacketService", "unsetDataPacketService")
                .setRequired(true));
        
        // Need FlowProgrammerService for programming flows
        c.add(createContainerServiceDependency(containerName).setService(
                IFlowProgrammerService.class).setCallbacks(
                "setFlowProgrammerService", "unsetFlowProgrammerService")
                .setRequired(true));
        
        // Need SwitchManager service for enumerating ports of switch
        c.add(createContainerServiceDependency(containerName).setService(
                ISwitchManager.class).setCallbacks(
                "setSwitchManagerService", "unsetSwitchManagerService")
                .setRequired(true));
    }

}
 

import org.opendaylight.controller.sal.packet.IListenDataPacket; //导入依赖的package包/类
public void configureInstance(Component c, Object imp, String containerName) {
    if (imp.equals(PacketHandler.class)) {
        log.trace("Configuring packet handler");
     
        // Export IListenDataPacket interface to receive packet-in events.
        Dictionary<String, Object> props = new Hashtable<String, Object>();
        props.put("salListenerName", "sdnmq");
        c.setInterface(new String[] {IListenDataPacket.class.getName()}, props);

        // Need the DataPacketService for decoding data packets
        c.add(createContainerServiceDependency(containerName).setService(
                IDataPacketService.class).setCallbacks(
                        "setDataPacketService", "unsetDataPacketService").setRequired(true));

    } else if (imp.equals(PacketForwarder.class)) {
        log.trace("Configuring packet forwarder");
        
        // Need the DataPacketService for encoding and sending packets
        c.add(createContainerServiceDependency(containerName).setService(
                IDataPacketService.class).setCallbacks(
                        "setDataPacketService", "unsetDataPacketService").setRequired(true));
        
        // Need SwitchManager service for finding nodes and node connectors
        c.add(createContainerServiceDependency(containerName).setService(
                ISwitchManager.class).setCallbacks(
                        "setSwitchManagerService", "unsetSwitchManagerService").setRequired(true));
    } else if (imp.equals(FlowProgrammer.class)) {
        log.trace("Configuring flow programmer");
        
        // Need SwitchManager service for finding nodes and node connectors
        c.add(createContainerServiceDependency(containerName).setService(
                ISwitchManager.class).setCallbacks(
                        "setSwitchManagerService", "unsetSwitchManagerService").setRequired(true));
        
        // Need FlowProgrammerService for programming flows
        c.add(createContainerServiceDependency(containerName).setService(
                IFlowProgrammerService.class).setCallbacks(
                        "setFlowProgrammerService", "unsetFlowProgrammerService").setRequired(true));
    }
}
 

import org.opendaylight.controller.sal.packet.IListenDataPacket; //导入依赖的package包/类
/**
 * Function that is called when configuration of the dependencies
 * is required.
 *
 * @param c dependency manager Component object, used for
 * configuring the dependencies exported and imported
 * @param imp Implementation class that is being configured,
 * needed as long as the same routine can configure multiple
 * implementations
 * @param containerName The containerName being configured, this allow
 * also optional per-container different behavior if needed, usually
 * should not be the case though.
 */
public void configureInstance(Component c, Object imp, String containerName) {
    if (imp.equals(ArpHandler.class)) {
        // export the service
        Dictionary<String, String> props = new Hashtable<String, String>();
        props.put("salListenerName", "arphandler");
        c.setInterface(new String[] { IHostFinder.class.getName(),
                IListenDataPacket.class.getName() }, props);

        c.add(createContainerServiceDependency(containerName).setService(
                ISwitchManager.class).setCallbacks("setSwitchManager",
                "unsetSwitchManager").setRequired(true));

        c.add(createContainerServiceDependency(containerName).setService(
                ITopologyManager.class).setCallbacks("setTopologyManager",
                "unsetTopologyMananger").setRequired(true));

       c.add(createContainerServiceDependency(containerName).setService(
                IDataPacketService.class).setCallbacks(
                "setDataPacketService", "unsetDataPacketService")
                .setRequired(true));

        // the Host Listener is optional
        c.add(createContainerServiceDependency(containerName).setService(
                IfHostListener.class).setCallbacks("setHostListener",
                "unsetHostListener").setRequired(false));

        // the IfIptoHost is a required dependency
        c.add(createContainerServiceDependency(containerName).setService(
                IfIptoHost.class).setCallbacks("setHostTracker",
                "unsetHostTracker").setRequired(true));
    }
}
 

import org.opendaylight.controller.sal.packet.IListenDataPacket; //导入依赖的package包/类
/**
 * Function that is called when configuration of the dependencies is
 * required.
 *
 * @param c
 *            dependency manager Component object, used for configuring the
 *            dependencies exported and imported
 * @param imp
 *            Implementation class that is being configured, needed as long
 *            as the same routine can configure multiple implementations
 * @param containerName
 *            The containerName being configured, this allow also optional
 *            per-container different behavior if needed, usually should not
 *            be the case though.
 */
@Override
public void configureInstance(Component c, Object imp, String containerName) {
    if (imp.equals(DeviceManagerImpl.class)) {
        // export the service
        // XXX - TODO merge with existing APIs
        Dictionary<String, String> props = new Hashtable<String, String>();
        props.put("salListenerName", "devicemanager");

        c.setInterface(
                new String[] { IDeviceService.class.getName(),
                        IfIptoHost.class.getName(),
                        IListenDataPacket.class.getName(),
                        ITopologyManagerAware.class.getName() }, props);

        c.add(createContainerServiceDependency(containerName)
                .setService(ISwitchManager.class)
                .setCallbacks("setSwitchManager", "unsetSwitchManager")
                .setRequired(false));

        c.add(createContainerServiceDependency(containerName)
                .setService(IDataPacketService.class)
                .setCallbacks("setDataPacketService",
                        "unsetDataPacketService").setRequired(true));

        c.add(createContainerServiceDependency(containerName)
                .setService(IfNewHostNotify.class)
                .setCallbacks("setNewHostNotify",
                        "unsetNewHostNotify").setRequired(false));

        // c.add(createContainerServiceDependency(containerName).setService(
        // IClusterContainerServices.class).setCallbacks(
        // "setClusterContainerService",
        // "unsetClusterContainerService").setRequired(true));
        c.add(createContainerServiceDependency(containerName)
                .setService(ITopologyManager.class)
                .setCallbacks("setTopologyManager", "unsetTopologyManager")
                .setRequired(false));
    }
}
 

import org.opendaylight.controller.sal.packet.IListenDataPacket; //导入依赖的package包/类
DataPacketListener(String name, IListenDataPacket s, String dependency,
        Match match) {
    this.listenerName = name;
    this.listener = s;
    this.dependency = dependency;
    this.match = match;
}
 

import org.opendaylight.controller.sal.packet.IListenDataPacket; //导入依赖的package包/类
/**
 * Loop for processing Received packets
 */
private void dispatchPacket(RawPacket pkt) {

    // for now we treat all listeners as serial listeners
    for (List<DataPacketListener> serialListeners : listenDataPacket) {
        for (DataPacketListener l : serialListeners) {

            // TODO: possibly deal with read-only and read-write packet
            // copies
            IListenDataPacket s = (l == null ? null : l.listener);
            if (s != null) {
                try {
                    // TODO Make sure to filter based on the match too,
                    // later on
                    PacketResult res = s.receiveDataPacket(pkt);
                    increaseStat("RXPacketSuccess");
                    if (res.equals(PacketResult.CONSUME)) {
                        increaseStat("RXPacketSerialExit");
                        break;
                    }
                } catch (Exception e) {
                    increaseStat("RXPacketFailedForException");
                }
            }
        }
    }
}
 

import org.opendaylight.controller.sal.packet.IListenDataPacket; //导入依赖的package包/类
/**
 * Function that is called when configuration of the dependencies
 * is required.
 *
 * @param c dependency manager Component object, used for
 * configuring the dependencies exported and imported
 * @param imp Implementation class that is being configured,
 * needed as long as the same routine can configure multiple
 * implementations
 * @param containerName The containerName being configured, this allow
 * also optional per-container different behavior if needed, usually
 * should not be the case though.
 */
public void configureInstance(Component c, Object imp, String containerName) {
    if (imp.equals(LoadBalancerService.class)) {
        // export the service
        Dictionary<String, String> props = new Hashtable<String, String>();
        props.put("salListenerName", "loadbalancer");

        c.setInterface(new String[] { IListenDataPacket.class.getName(),
                    IConfigManager.class.getName()}, props);

        c.add(createContainerServiceDependency(containerName).setService(
                IDataPacketService.class).setCallbacks(
                "setDataPacketService", "unsetDataPacketService")
                .setRequired(true));

        c.add(createContainerServiceDependency(containerName).setService(
                IRouting.class).setCallbacks("setRouting", "unsetRouting")
                .setRequired(false));

        c.add(createContainerServiceDependency(containerName).setService(
                IfIptoHost.class).setCallbacks("setHostTracker",
                "unsetHostTracker").setRequired(true));

        c.add(createContainerServiceDependency(containerName).setService(
                IForwardingRulesManager.class).setCallbacks(
                "setForwardingRulesManager", "unsetForwardingRulesManager")
                .setRequired(true));
    }
}
 

import org.opendaylight.controller.sal.packet.IListenDataPacket; //导入依赖的package包/类
/**
 * Function that is called when configuration of the dependencies
 * is required.
 *
 * @param c dependency manager Component object, used for
 * configuring the dependencies exported and imported
 * @param imp Implementation class that is being configured,
 * needed as long as the same routine can configure multiple
 * implementations
 * @param containerName The containerName being configured, this allow
 * also optional per-container different behavior if needed, usually
 * should not be the case though.
 */
public void configureInstance(Component c, Object imp, String containerName) {
    if (imp.equals(QoSHandler.class)) {
        // export the service
        Dictionary<String, String> props = new Hashtable<String, String>();
        props.put("salListenerName", "qoshandler");
        c.setInterface(new String[] { IPluginOutDataPacketService.class.getName(),
                IListenDataPacket.class.getName() }, props);

        c.add(createContainerServiceDependency(containerName).setService(
                ISwitchManager.class).setCallbacks("setSwitchManager",
                "unsetSwitchManager").setRequired(true));

        c.add(createContainerServiceDependency(containerName).setService(
                ITopologyManager.class).setCallbacks("setTopologyManager",
                "unsetTopologyMananger").setRequired(true));

       c.add(createContainerServiceDependency(containerName).setService(
                IDataPacketService.class).setCallbacks(
                "setDataPacketService", "unsetDataPacketService")
                .setRequired(true));

        // the Host Listener is optional
        c.add(createContainerServiceDependency(containerName).setService(
                IfHostListener.class).setCallbacks("setHostListener",
                "unsetHostListener").setRequired(false));

        // the IfIptoHost is a required dependency
        c.add(createContainerServiceDependency(containerName).setService(
                IfIptoHost.class).setCallbacks("setHostTracker",
                "unsetHostTracker").setRequired(true));
    }
}
 

import org.opendaylight.controller.sal.packet.IListenDataPacket; //导入依赖的package包/类
@Override
public void configureInstance(Component c, Object imp, String containerName) {
    if (imp.equals(JumpIP.class)) {
        // export the service needed to listen to topology updates
        final Dictionary<String, Object> props = new Hashtable<String, Object>();
        props.put("StatisgetListenerName", "Statisget");
        props.put("salListenerName", "datapacketget");
        props.put("topoListenerName", "topoget");
        
        //listen topology to update topo & handle packet_in
        c.setInterface(new String[] { ITopologyManagerAware.class.getName(),
                 IListenDataPacket.class.getName() }, props);
        
        //statistics service
        c.add(createContainerServiceDependency(containerName)
            .setService(IStatisticsManager.class)
            .setCallbacks("setStatisticsManager", "unsetStatisticsManager")
            .setRequired(false));

        //flowprogrammer service
        c.add(createContainerServiceDependency(containerName)
            .setService(IFlowProgrammerService.class)
            .setCallbacks("setFlowProgrammerService","unsetFlowProgrammerService")
            .setRequired(true));

        //topology service
        c.add(createContainerServiceDependency(containerName)
            .setService(ITopologyManager.class)
            .setCallbacks("setTopologyManager", "unsetTopologyManager")
            .setRequired(true));
        
        //switch service
        c.add(createContainerServiceDependency(containerName)
            .setService(ISwitchManager.class)
            .setCallbacks("setSwitchManager", "unsetSwitchManager")
            .setRequired(false));
        c.add(createContainerServiceDependency(containerName)
            .setService(IfIptoHost.class)
            .setCallbacks("setHostTracker", "unsetHostTracker")
            .setRequired(true));
        c.add(createContainerServiceDependency(containerName)
            .setService(IDataPacketService.class)
            .setCallbacks("setDataPacketService", "unsetDataPacketService")
            .setRequired(true));
        c.add(createContainerServiceDependency(containerName)
            .setService(IForwardingRulesManager.class)
            .setCallbacks("setForwarder", "unsetForwarder")
            .setRequired(true));   
    }
}
 

import org.opendaylight.controller.sal.packet.IListenDataPacket; //导入依赖的package包/类
void unsetListenDataPacket(Map props, IListenDataPacket s) {
    if (this.listenDataPacket == null || this.indexDataPacket == null) {
        logger.error("data structure to store data is NULL");
        return;
    }
    logger.trace("Received UNsetListenDataPacket request");
    for (Object e : props.entrySet()) {
        Map.Entry entry = (Map.Entry) e;
        logger.trace("Prop key:({}) value:({})",entry.getKey(), entry.getValue());
    }

    String listenerName = null;
    Object value;
    // Read the listenerName
    value = props.get("salListenerName");
    if (value instanceof String) {
        listenerName = (String) value;
    }

    if (listenerName == null) {
        logger.error("Trying to set a listener without a Name");
        return;
    }

    DataPacketListener l = new DataPacketListener(listenerName, s, null,
            null);
    if (!this.indexDataPacket.contains(l)) {
        logger.error("trying to remove a non-existing element");
    } else {
        logger.debug("removing listener: {}", listenerName);
        for (List<DataPacketListener> serialListeners : this.listenDataPacket) {
            int i = 0;
            boolean done = false;
            for (i = 0; i < serialListeners.size(); i++) {
                if (serialListeners.get(i).equals(l)) {
                    serialListeners.remove(i);
                    done = true;
                    break;
                }
            }
            // Now remove a serialListener that maybe empty
            if (serialListeners.isEmpty()) {
                this.listenDataPacket.remove(serialListeners);
            }
            // If we did fine the element, lets break early
            if (done) {
                break;
            }
        }

        this.indexDataPacket.remove(l);
    }
}