opendaylight/sal/yang-prototype/sal/sal-binding-broker-impl/src/main/java/org/opendaylight/controller/sal/binding/impl/BindingBrokerImpl.java

   1 package org.opendaylight.controller.sal.binding.impl;
   2
   3 import java.util.HashMap;
   4 import java.util.HashSet;
   5 import java.util.Map;
   6 import java.util.Set;
   7
   8 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
   9 import org.opendaylight.controller.sal.binding.api.BindingAwareConsumer;
  10 import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
  11 import org.opendaylight.controller.sal.binding.api.BindingAwareService;
  12 import org.opendaylight.controller.sal.binding.spi.SALBindingModule;
  13 import org.opendaylight.controller.yang.binding.RpcService;
  14 import org.slf4j.Logger;
  15 import org.slf4j.LoggerFactory;
  16
  17 public class BindingBrokerImpl implements BindingAwareBroker {
  18
  19     private static Logger log = LoggerFactory
  20             .getLogger(BindingBrokerImpl.class);
  21
  22     private Set<ConsumerSessionImpl> sessions = new HashSet<ConsumerSessionImpl>();
  23     private Set<ProviderSessionImpl> providerSessions = new HashSet<ProviderSessionImpl>();
  24
  25     private Set<SALBindingModule> modules = new HashSet<SALBindingModule>();
  26     private Map<Class<? extends BindingAwareService>, SALBindingModule> salServiceProviders = new HashMap<Class<? extends BindingAwareService>, SALBindingModule>();
  27
  28     @Override
  29     public ConsumerSession registerConsumer(BindingAwareConsumer consumer) {
  30         checkPredicates(consumer);
  31         log.info("Registering consumer " + consumer);
  32
  33         ConsumerSessionImpl session = newSessionFor(consumer);
  34         consumer.onSessionInitialized(session);
  35
  36         sessions.add(session);
  37
  38         return session;
  39
  40     }
  41
  42     @Override
  43     public ProviderSession registerProvider(BindingAwareProvider provider) {
  44         checkPredicates(provider);
  45
  46         ProviderSessionImpl session = newSessionFor(provider);
  47         provider.onSessionInitiated(session);
  48
  49         providerSessions.add(session);
  50         return session;
  51     }
  52
  53     public void addModule(SALBindingModule module) {
  54         log.info("Registering broker module " + module);
  55         if (modules.contains(module)) {
  56             log.error("Module already registered");
  57             throw new IllegalArgumentException("Module already exists.");
  58         }
  59
  60         Set<Class<? extends BindingAwareService>> provServices = module
  61                 .getProvidedServices();
  62         for (Class<? extends BindingAwareService> serviceType : provServices) {
  63             log.info("  Registering session service implementation: "
  64                     + serviceType.getCanonicalName());
  65             salServiceProviders.put(serviceType, module);
  66         }
  67     }
  68
  69     public void consumerSessionClosed(ConsumerSessionImpl consumerSessionImpl) {
  70         sessions.remove(consumerSessionImpl);
  71         providerSessions.remove(consumerSessionImpl);
  72     }
  73
  74     private void checkPredicates(BindingAwareProvider prov) {
  75         if (prov == null)
  76             throw new IllegalArgumentException("Provider should not be null.");
  77         for (ProviderSessionImpl session : providerSessions) {
  78             if (prov.equals(session.getProvider()))
  79                 throw new IllegalStateException("Provider already registered");
  80         }
  81
  82     }
  83
  84     private void checkPredicates(BindingAwareConsumer cons) {
  85         if (cons == null)
  86             throw new IllegalArgumentException("Consumer should not be null.");
  87         for (ConsumerSessionImpl session : sessions) {
  88             if (cons.equals(session.getConsumer()))
  89                 throw new IllegalStateException("Consumer already registered");
  90         }
  91     }
  92
  93     private ConsumerSessionImpl newSessionFor(BindingAwareConsumer cons) {
  94         return new ConsumerSessionImpl(cons);
  95     }
  96
  97     private ProviderSessionImpl newSessionFor(BindingAwareProvider provider) {
  98         return new ProviderSessionImpl(provider);
  99     }
 100
 101     private <T extends BindingAwareService> T newSALServiceForSession(
 102             Class<T> service, ConsumerSession session) {
 103
 104         SALBindingModule serviceProvider = salServiceProviders.get(service);
 105         if (serviceProvider == null) {
 106             return null;
 107         }
 108         return serviceProvider.getServiceForSession(service, session);
 109
 110     }
 111
 112     private class ConsumerSessionImpl implements
 113             BindingAwareBroker.ConsumerSession {
 114
 115         private final BindingAwareConsumer consumer;
 116         private Map<Class<? extends BindingAwareService>, BindingAwareService> sessionSalServices = new HashMap<Class<? extends BindingAwareService>, BindingAwareService>();
 117
 118         public ConsumerSessionImpl(BindingAwareConsumer cons) {
 119             this.consumer = cons;
 120         }
 121
 122         @Override
 123         public <T extends BindingAwareService> T getSALService(Class<T> service) {
 124
 125             BindingAwareService serv = sessionSalServices.get(service);
 126             if (serv != null) {
 127                 if (service.isInstance(serv)) {
 128                     @SuppressWarnings("unchecked")
 129                     T ret = (T) serv;
 130                     return ret;
 131                 } else {
 132                     log.error("Implementation for service " + service.getName()
 133                             + " does not implement the service interface");
 134                     throw new IllegalStateException("Service implementation "
 135                             + serv.getClass().getName() + "does not implement "
 136                             + service.getName());
 137                 }
 138             } else {
 139                 T ret = BindingBrokerImpl.this.newSALServiceForSession(service,
 140                         this);
 141                 if (ret != null) {
 142                     sessionSalServices.put(service, ret);
 143                 }
 144                 return ret;
 145             }
 146         }
 147
 148         @Override
 149         public <T extends RpcService> T getRpcService(Class<T> module) {
 150             // TODO Implement this method
 151             throw new UnsupportedOperationException("Not implemented");
 152         }
 153
 154         public BindingAwareConsumer getConsumer() {
 155             return this.consumer;
 156         }
 157
 158     }
 159
 160     private class ProviderSessionImpl extends ConsumerSessionImpl implements
 161             BindingAwareBroker.ProviderSession {
 162
 163         private final BindingAwareProvider provider;
 164
 165         public ProviderSessionImpl(BindingAwareProvider provider2) {
 166             super(null);
 167             this.provider = provider2;
 168         }
 169
 170         @Override
 171         public void addRpcImplementation(RpcService implementation) {
 172             // TODO Implement this method
 173             throw new UnsupportedOperationException("Not implemented");
 174         }
 175
 176         @Override
 177         public void removeRpcImplementation(RpcService implementation) {
 178             // TODO Implement this method
 179             throw new UnsupportedOperationException("Not implemented");
 180         }
 181
 182         public BindingAwareProvider getProvider() {
 183             return this.provider;
 184         }
 185
 186     }
 187
 188 }