--- /dev/null
+package org.opendaylight.controller.sal.binding.impl;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
+import org.opendaylight.controller.sal.binding.api.BindingAwareConsumer;
+import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
+import org.opendaylight.controller.sal.binding.api.BindingAwareService;
+import org.opendaylight.controller.sal.binding.spi.SALBindingModule;
+import org.opendaylight.controller.yang.binding.RpcService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class BindingBrokerImpl implements BindingAwareBroker {
+
+ private static Logger log = LoggerFactory
+ .getLogger(BindingBrokerImpl.class);
+
+ private Set<ConsumerSessionImpl> sessions = new HashSet<ConsumerSessionImpl>();
+ private Set<ProviderSessionImpl> providerSessions = new HashSet<ProviderSessionImpl>();
+
+ private Set<SALBindingModule> modules = new HashSet<SALBindingModule>();
+ private Map<Class<? extends BindingAwareService>, SALBindingModule> salServiceProviders = new HashMap<Class<? extends BindingAwareService>, SALBindingModule>();
+
+ @Override
+ public ConsumerSession registerConsumer(BindingAwareConsumer consumer) {
+ checkPredicates(consumer);
+ log.info("Registering consumer " + consumer);
+
+ ConsumerSessionImpl session = newSessionFor(consumer);
+ consumer.onSessionInitialized(session);
+
+ sessions.add(session);
+
+ return session;
+
+ }
+
+ @Override
+ public ProviderSession registerProvider(BindingAwareProvider provider) {
+ checkPredicates(provider);
+
+ ProviderSessionImpl session = newSessionFor(provider);
+ provider.onSessionInitiated(session);
+
+ providerSessions.add(session);
+ return session;
+ }
+
+ public void addModule(SALBindingModule module) {
+ log.info("Registering broker module " + module);
+ if (modules.contains(module)) {
+ log.error("Module already registered");
+ throw new IllegalArgumentException("Module already exists.");
+ }
+
+ Set<Class<? extends BindingAwareService>> provServices = module
+ .getProvidedServices();
+ for (Class<? extends BindingAwareService> serviceType : provServices) {
+ log.info(" Registering session service implementation: "
+ + serviceType.getCanonicalName());
+ salServiceProviders.put(serviceType, module);
+ }
+ }
+
+ public void consumerSessionClosed(ConsumerSessionImpl consumerSessionImpl) {
+ sessions.remove(consumerSessionImpl);
+ providerSessions.remove(consumerSessionImpl);
+ }
+
+ private void checkPredicates(BindingAwareProvider prov) {
+ if (prov == null)
+ throw new IllegalArgumentException("Provider should not be null.");
+ for (ProviderSessionImpl session : providerSessions) {
+ if (prov.equals(session.getProvider()))
+ throw new IllegalStateException("Provider already registered");
+ }
+
+ }
+
+ private void checkPredicates(BindingAwareConsumer cons) {
+ if (cons == null)
+ throw new IllegalArgumentException("Consumer should not be null.");
+ for (ConsumerSessionImpl session : sessions) {
+ if (cons.equals(session.getConsumer()))
+ throw new IllegalStateException("Consumer already registered");
+ }
+ }
+
+ private ConsumerSessionImpl newSessionFor(BindingAwareConsumer cons) {
+ return new ConsumerSessionImpl(cons);
+ }
+
+ private ProviderSessionImpl newSessionFor(BindingAwareProvider provider) {
+ return new ProviderSessionImpl(provider);
+ }
+
+ private <T extends BindingAwareService> T newSALServiceForSession(
+ Class<T> service, ConsumerSession session) {
+
+ SALBindingModule serviceProvider = salServiceProviders.get(service);
+ if (serviceProvider == null) {
+ return null;
+ }
+ return serviceProvider.getServiceForSession(service, session);
+
+ }
+
+ private class ConsumerSessionImpl implements
+ BindingAwareBroker.ConsumerSession {
+
+ private final BindingAwareConsumer consumer;
+ private Map<Class<? extends BindingAwareService>, BindingAwareService> sessionSalServices = new HashMap<Class<? extends BindingAwareService>, BindingAwareService>();
+
+ public ConsumerSessionImpl(BindingAwareConsumer cons) {
+ this.consumer = cons;
+ }
+
+ @Override
+ public <T extends BindingAwareService> T getSALService(Class<T> service) {
+
+ BindingAwareService serv = sessionSalServices.get(service);
+ if (serv != null) {
+ if (service.isInstance(serv)) {
+ @SuppressWarnings("unchecked")
+ T ret = (T) serv;
+ return ret;
+ } else {
+ log.error("Implementation for service " + service.getName()
+ + " does not implement the service interface");
+ throw new IllegalStateException("Service implementation "
+ + serv.getClass().getName() + "does not implement "
+ + service.getName());
+ }
+ } else {
+ T ret = BindingBrokerImpl.this.newSALServiceForSession(service,
+ this);
+ if (ret != null) {
+ sessionSalServices.put(service, ret);
+ }
+ return ret;
+ }
+ }
+
+ @Override
+ public <T extends RpcService> T getRpcService(Class<T> module) {
+ // TODO Implement this method
+ throw new UnsupportedOperationException("Not implemented");
+ }
+
+ public BindingAwareConsumer getConsumer() {
+ return this.consumer;
+ }
+
+ }
+
+ private class ProviderSessionImpl extends ConsumerSessionImpl implements
+ BindingAwareBroker.ProviderSession {
+
+ private final BindingAwareProvider provider;
+
+ public ProviderSessionImpl(BindingAwareProvider provider2) {
+ super(null);
+ this.provider = provider2;
+ }
+
+ @Override
+ public void addRpcImplementation(RpcService implementation) {
+ // TODO Implement this method
+ throw new UnsupportedOperationException("Not implemented");
+ }
+
+ @Override
+ public void removeRpcImplementation(RpcService implementation) {
+ // TODO Implement this method
+ throw new UnsupportedOperationException("Not implemented");
+ }
+
+ public BindingAwareProvider getProvider() {
+ return this.provider;
+ }
+
+ }
+
+}
Code Review / controller.git / blobdiff