Java IListenInventoryUpdates类代码示例

import org.opendaylight.controller.sal.inventory.IListenInventoryUpdates; //导入依赖的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
 */
public void configureGlobalInstance(Component c, Object imp) {
    if (imp.equals(Inventory.class)) {
        Dictionary<String, Object> props = new Hashtable<String, Object>();
        props.put("scope", "Global");
        // export the service
        c.setInterface(
                new String[] { IPluginOutInventoryService.class.getName(),
                        IInventoryService.class.getName() }, props);

        // Now lets add a service dependency to make sure the
        // provider of service exists
        c.add(createServiceDependency()
                .setService(IListenInventoryUpdates.class, "(scope=Global)")
                .setCallbacks("setUpdateService", "unsetUpdateService")
                .setRequired(false));
        c.add(createServiceDependency()
                .setService(IPluginInInventoryService.class, "(scope=Global)")
                .setCallbacks("setPluginService", "unsetPluginService")
                .setRequired(true));
    }
}
 

import org.opendaylight.controller.sal.inventory.IListenInventoryUpdates; //导入依赖的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(StatisticsManager.class)) {
        // export the service
        c.setInterface(new String[] {
                IStatisticsManager.class.getName(),
                IReadServiceListener.class.getName(),
                IListenInventoryUpdates.class.getName() }, null);

        c.add(createContainerServiceDependency(containerName).setService(IReadService.class)
                .setCallbacks("setReaderService", "unsetReaderService").setRequired(true));
        c.add(createContainerServiceDependency(containerName).setService(IClusterContainerServices.class)
                .setCallbacks("setClusterContainerService", "unsetClusterContainerService").setRequired(true));
        c.add(createContainerServiceDependency(containerName).setService(IContainer.class)
                .setCallbacks("setIContainer", "unsetIContainer").setRequired(true));

    }
}
 

import org.opendaylight.controller.sal.inventory.IListenInventoryUpdates; //导入依赖的package包/类
/**
 * Configure the dependency for a given instance Global
 *
 * @param c Component assigned for this instance, this will be
 * what will be used for configuration
 * @param imp implementation to be configured
 * @param containerName container on which the configuration happens
 */
protected void configureGlobalInstance(Component c, Object imp) {
    if (imp.equals(ConnectionManager.class)) {
        Dictionary<String, Object> props = new Hashtable<String, Object>();
        Set<String> propSet = new HashSet<String>();
        propSet.add("connectionmanager.nodeconnections");
        props.put("cachenames", propSet);
        props.put("scope", "Global");

        // export the service
        c.setInterface(new String[] { IConnectionManager.class.getName(),
                                      IConnectionListener.class.getName(),
                                      ICoordinatorChangeAware.class.getName(),
                                      IListenInventoryUpdates.class.getName(),
                                      ICacheUpdateAware.class.getName()},
                                      props);

        c.add(createServiceDependency()
                .setService(IClusterGlobalServices.class)
                .setCallbacks("setClusterServices", "unsetClusterServices")
                .setRequired(true));

        c.add(createServiceDependency().setService(IConnectionService.class)
                .setCallbacks("setConnectionService", "unsetConnectionService")
                .setRequired(true));
    }
}
 

import org.opendaylight.controller.sal.inventory.IListenInventoryUpdates; //导入依赖的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(SwitchManagerImpl.class)) {
        Dictionary<String, Set<String>> props = new Hashtable<String, Set<String>>();
        Set<String> propSet = new HashSet<String>();
        propSet.add("switchmanager.configSaveEvent");
        props.put("cachenames", propSet);
        // export the service
        c.setInterface(new String[] {
                IListenInventoryUpdates.class.getName(),
                ISwitchManager.class.getName(),
                ICacheUpdateAware.class.getName(),
                IConfigurationContainerAware.class.getName() }, props);

        // Now lets add a service dependency to make sure the
        // provider of service exists
        c.add(createContainerServiceDependency(containerName).setService(
                IInventoryService.class).setCallbacks(
                "setInventoryService", "unsetInventoryService")
                .setRequired(false));
        c.add(createContainerServiceDependency(containerName).setService(
                ISwitchManagerAware.class).setCallbacks(
                "setSwitchManagerAware", "unsetSwitchManagerAware")
                .setRequired(false));
        c.add(createContainerServiceDependency(containerName).setService(
                IInventoryListener.class).setCallbacks(
                "setInventoryListener", "unsetInventoryListener")
                .setRequired(false));
        c.add(createContainerServiceDependency(containerName).setService(
                ISpanAware.class).setCallbacks("setSpanAware",
                "unsetSpanAware").setRequired(false));
        c.add(createContainerServiceDependency(containerName).setService(
                IClusterContainerServices.class).setCallbacks(
                "setClusterContainerService",
                "unsetClusterContainerService").setRequired(true));
    }
}
 

import org.opendaylight.controller.sal.inventory.IListenInventoryUpdates; //导入依赖的package包/类
@Override
public void updateNode(Node node, UpdateType type, Set<Property> props) {
    if (type == null) {
        logger.trace("Input type is null");
        return;
    }

    logger.trace("{} {}", node, type);

    for (IListenInventoryUpdates s : this.updateService) {
        s.updateNode(node, type, props);
    }
}
 

import org.opendaylight.controller.sal.inventory.IListenInventoryUpdates; //导入依赖的package包/类
@Override
public void updateNodeConnector(NodeConnector nodeConnector,
        UpdateType type, Set<Property> props) {
    if (type == null) {
        logger.trace("Input type is null");
        return;
    }

    logger.trace("{} {}", nodeConnector, type);

    for (IListenInventoryUpdates s : this.updateService) {
        s.updateNodeConnector(nodeConnector, type, props);
    }
}
 

import org.opendaylight.controller.sal.inventory.IListenInventoryUpdates; //导入依赖的package包/类
public void setUpdateService(IListenInventoryUpdates service) {
    logger.trace("Got update service set request {}", service);
    this.updateService.add(service);
}
 

import org.opendaylight.controller.sal.inventory.IListenInventoryUpdates; //导入依赖的package包/类
public void unsetUpdateService(IListenInventoryUpdates service) {
    logger.trace("Got a service UNset request");
    this.updateService.remove(service);
}