Java IClusterGlobalServices类代码示例

import org.opendaylight.controller.clustering.services.IClusterGlobalServices; //导入依赖的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(ConfigurationImpl.class)) {
        Dictionary<String, Set<String>> props = new Hashtable<String, Set<String>>();
        Set<String> propSet = new HashSet<String>();
        propSet.add("config.event.save");
        props.put("cachenames", propSet);

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

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

        c.add(createServiceDependency().setService(
                IConfigurationAware.class).setCallbacks(
                        "addConfigurationAware", "removeConfigurationAware")
                        .setRequired(false));
    }
}
 

import org.opendaylight.controller.clustering.services.IClusterGlobalServices; //导入依赖的package包/类
public static AbstractScheme getScheme(ConnectionMgmtScheme scheme, IClusterGlobalServices clusterServices) {
    if (scheme == ConnectionMgmtScheme.SINGLE_CONTROLLER) {
        return SingleControllerScheme.getScheme(clusterServices);
    } else if (scheme == ConnectionMgmtScheme.ROUND_ROBIN) {
        return RoundRobinScheme.getScheme(clusterServices);
    } else if (scheme == ConnectionMgmtScheme.LOAD_BALANCED) {
        return LoadBalancedScheme.getScheme(clusterServices);
    } else if (scheme == ConnectionMgmtScheme.ANY_CONTROLLER_ONE_MASTER) {
        return AnyControllerScheme.getScheme(clusterServices);
    }
    return null;
}
 

import org.opendaylight.controller.clustering.services.IClusterGlobalServices; //导入依赖的package包/类
protected AbstractScheme(IClusterGlobalServices clusterServices, ConnectionMgmtScheme type) {
    this.clusterServices = clusterServices;
    if (type != null) name = type.name();
    else name = "UNKNOWN";
    if (clusterServices != null) {
        allocateCaches();
        retrieveCaches();
    }
}
 

import org.opendaylight.controller.clustering.services.IClusterGlobalServices; //导入依赖的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.clustering.services.IClusterGlobalServices; //导入依赖的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(ContainerManager.class)) {

        // export the service
        c.setInterface(new String[] { IContainerManager.class.getName() },
                null);

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

        // Key kick-starter for container creation in each component
        c.add(createServiceDependency().setService(IContainerAware.class)
                .setCallbacks("setIContainerAware", "unsetIContainerAware")
                .setRequired(false));

        // Optional interface expected to be exported by the
        // protocol plugins to setup proper filtering based on
        // slicing events
        c.add(createServiceDependency()
                .setService(IContainerListener.class).setCallbacks(
                        "setIContainerListener", "unsetIContainerListener")
                .setRequired(false));
    }
}
 

import org.opendaylight.controller.clustering.services.IClusterGlobalServices; //导入依赖的package包/类
@Before
public void areWeReady() {
    assertNotNull(bc);
    boolean debugit = false;
    Bundle b[] = bc.getBundles();
    for (int i = 0; i < b.length; i++) {
        int state = b[i].getState();
        if (state != Bundle.ACTIVE && state != Bundle.RESOLVED) {
            log.debug("Bundle:" + b[i].getSymbolicName() + " state:"
                      + stateToString(state));
            debugit = true;
        }
    }
    if (debugit) {
        log.debug("Do some debugging because some bundle is "
                  + "unresolved");
    }

    // Assert if true, if false we are good to go!
    assertFalse(debugit);

    this.clusterServices = (IClusterServices)ServiceHelper
        .getGlobalInstance(IClusterServices.class, this);
    assertNotNull(this.clusterServices);

    this.clusterDefaultServices = (IClusterContainerServices)ServiceHelper
        .getInstance(IClusterContainerServices.class, "default", this);
    assertNotNull(this.clusterDefaultServices);

    this.clusterGlobalServices = (IClusterGlobalServices)ServiceHelper
        .getGlobalInstance(IClusterGlobalServices.class, this);
    assertNotNull(this.clusterGlobalServices);
}
 

import org.opendaylight.controller.clustering.services.IClusterGlobalServices; //导入依赖的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
 */
@Override
public void configureGlobalInstance(Component c, Object imp) {
    if (imp.equals(ClusterManager.class)) {
        // export the service for Apps and Plugins
        c.setInterface(new String[] { IClusterServices.class.getName(), IContainerAware.class.getName() }, null);
    }

    if (imp.equals(ClusterGlobalManager.class)) {
        c.setInterface(new String[] { IClusterGlobalServices.class.getName() }, null);

        c.add(createServiceDependency()
              .setService(IClusterServices.class)
              .setCallbacks("setClusterService", "unsetClusterService")
              .setRequired(true));

        // CacheUpdate services will be none or many so the
        // dependency is optional
        c.add(createServiceDependency()
              .setService(ICacheUpdateAware.class)
              .setCallbacks("setCacheUpdateAware", "unsetCacheUpdateAware")
              .setRequired(false));

        // Coordinator change event can be one or many so
        // dependency is optional
        c.add(createServiceDependency()
              .setService(ICoordinatorChangeAware.class)
              .setCallbacks("setCoordinatorChangeAware", "unsetCoordinatorChangeAware")
              .setRequired(false));
    }
}
 

import org.opendaylight.controller.clustering.services.IClusterGlobalServices; //导入依赖的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(UserManagerImpl.class)) {
        // export the service
        Dictionary<String, Set<String>> props = new Hashtable<String, Set<String>>();
        Set<String> propSet = new HashSet<String>();
        propSet.add("usermanager.localUserSaveConfigEvent");
        propSet.add("usermanager.remoteServerSaveConfigEvent");
        propSet.add("usermanager.authorizationSaveConfigEvent");
        props.put("cachenames", propSet);

        // export the service
        c.setInterface(new String[] { ICacheUpdateAware.class.getName(),
                IUserManager.class.getName(),
                IConfigurationAware.class.getName() }, props);

        c.add(createServiceDependency().setService(
                IClusterGlobalServices.class).setCallbacks(
                "setClusterGlobalService", "unsetClusterGlobalService")
                .setRequired(true));

        c.add(createServiceDependency().setService(IAAAProvider.class)
                .setCallbacks("addAAAProvider", "removeAAAProvider")
                .setRequired(false));

        c.add(createServiceDependency().setService(
                IContainerAuthorization.class).setCallbacks(
                "setContainerAuthClient", "unsetContainerAuthClient")
                .setRequired(false));

        c.add(createServiceDependency().setService(
                IResourceAuthorization.class).setCallbacks(
                "setAppAuthClient", "unsetAppAuthClient")
                .setRequired(false));
    }
}
 

import org.opendaylight.controller.clustering.services.IClusterGlobalServices; //导入依赖的package包/类
protected SingleControllerScheme(IClusterGlobalServices clusterServices) {
    super(clusterServices, ConnectionMgmtScheme.SINGLE_CONTROLLER);
}
 

import org.opendaylight.controller.clustering.services.IClusterGlobalServices; //导入依赖的package包/类
public static AbstractScheme getScheme(IClusterGlobalServices clusterServices) {
    if (myScheme == null) {
        myScheme = new SingleControllerScheme(clusterServices);
    }
    return myScheme;
}
 

import org.opendaylight.controller.clustering.services.IClusterGlobalServices; //导入依赖的package包/类
protected LoadBalancedScheme(IClusterGlobalServices clusterServices) {
    super(clusterServices, ConnectionMgmtScheme.LOAD_BALANCED);
}
 

import org.opendaylight.controller.clustering.services.IClusterGlobalServices; //导入依赖的package包/类
public static AbstractScheme getScheme(IClusterGlobalServices clusterServices) {
    return null;
}
 

import org.opendaylight.controller.clustering.services.IClusterGlobalServices; //导入依赖的package包/类
protected RoundRobinScheme(IClusterGlobalServices clusterServices) {
    super(clusterServices, ConnectionMgmtScheme.ROUND_ROBIN);
    // TODO Auto-generated constructor stub
}
 

import org.opendaylight.controller.clustering.services.IClusterGlobalServices; //导入依赖的package包/类
protected AnyControllerScheme(IClusterGlobalServices clusterServices) {
    super(clusterServices, ConnectionMgmtScheme.ANY_CONTROLLER_ONE_MASTER);
}
 

import org.opendaylight.controller.clustering.services.IClusterGlobalServices; //导入依赖的package包/类
public static AbstractScheme getScheme(IClusterGlobalServices clusterServices) {
    if (myScheme == null) {
        myScheme = new AnyControllerScheme(clusterServices);
    }
    return myScheme;
}