org.opendaylight.snmp4sdn.internal.FlowProgrammerNotifier Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of snmp4sdn Show documentation
The snmp4sdn plugin
The newest version!
/*
 * Copyright (c) 2013 Industrial Technology Research Institute of Taiwan 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
 */

/*
This code reused the code base of OpenFlow plugin contributed by Cisco Systems, Inc. Their efforts are appreciated.
*/

package org.opendaylight.snmp4sdn.internal;

import org.apache.felix.dm.Component;
import org.opendaylight.snmp4sdn.IFlowProgrammerNotifier;
import org.opendaylight.controller.sal.core.Node;
import org.opendaylight.controller.sal.flowprogrammer.Flow;
import org.opendaylight.controller.sal.flowprogrammer.IPluginOutFlowProgrammerService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Flow Programmer Notifier class for relaying asynchronous messages received
 * from the network node to the listeners on the proper container
 */
public class FlowProgrammerNotifier implements IFlowProgrammerNotifier {
    protected static final Logger logger = LoggerFactory
            .getLogger(FlowProgrammerNotifier.class);
    private IPluginOutFlowProgrammerService salNotifier;

    public FlowProgrammerNotifier() {
        salNotifier = null;
    }

    void init(Component c) {
        logger.debug("FlowProgrammerNotifier: INIT called!");
    }

    /**
     * Function called by the dependency manager when at least one dependency
     * become unsatisfied or when the component is shutting down because for
     * example bundle is being stopped.
     *
     */
    void destroy() {
        logger.debug("FlowProgrammerNotifier: DESTROY called!");
    }

    /**
     * Function called by dependency manager after "init ()" is called and after
     * the services provided by the class are registered in the service registry
     *
     */
    void start() {
        logger.debug("FlowProgrammerNotifier: START called!");
    }

    /**
     * Function called by the dependency manager before the services exported by
     * the component are unregistered, this will be followed by a "destroy ()"
     * calls
     *
     */
    void stop() {
        logger.debug("FlowProgrammerNotifier: STOP called!");
    }

    public void setPluginOutFlowProgrammerService(
            IPluginOutFlowProgrammerService s) {
        this.salNotifier = s;
    }

    public void unsetPluginOutFlowProgrammerService(
            IPluginOutFlowProgrammerService s) {
        if (this.salNotifier == s) {
            this.salNotifier = null;
        }
    }

    @Override
    public void flowRemoved(Node node, Flow flow) {
        if (salNotifier != null) {
            salNotifier.flowRemoved(node, flow);
        } else {
            logger.warn("Unable to relay switch message to upper layer");
        }
    }

    @Override
    public void flowErrorReported(Node node, long rid, Object err) {
        if (salNotifier != null) {
            salNotifier.flowErrorReported(node, rid, err);
        } else {
            logger.warn("Unable to relay switch error message to upper layer");
        }
    }

}