openflowplugin/src/main/java/org/opendaylight/openflowplugin/openflow/md/core/session/SessionContextOFImpl.java

   1 /**
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.openflowplugin.openflow.md.core.session;
  10
  11 import java.util.ArrayList;
  12 import java.util.Collections;
  13 import java.util.HashMap;
  14 import java.util.List;
  15 import java.util.Map;
  16 import java.util.Map.Entry;
  17 import java.util.Set;
  18 import java.util.concurrent.ConcurrentHashMap;
  19 import java.util.concurrent.atomic.AtomicLong;
  20
  21 import com.google.common.cache.Cache;
  22 import com.google.common.cache.CacheBuilder;
  23
  24 import java.util.concurrent.TimeUnit;
  25
  26 import org.opendaylight.openflowplugin.openflow.md.ModelDrivenSwitch;
  27 import org.opendaylight.openflowplugin.openflow.md.core.ConnectionConductor;
  28 import org.opendaylight.openflowplugin.openflow.md.core.SwitchConnectionDistinguisher;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetFeaturesOutput;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PortGrouping;
  31 import org.opendaylight.yangtools.concepts.CompositeObjectRegistration;
  32
  33 /**
  34  * @author mirehak
  35  */
  36 public class SessionContextOFImpl implements SessionContext {
  37
  38     private GetFeaturesOutput features;
  39     private ConnectionConductor primaryConductor;
  40     private ConcurrentHashMap<SwitchConnectionDistinguisher, ConnectionConductor> auxiliaryConductors;
  41     private boolean valid;
  42     private SwitchConnectionDistinguisher sessionKey;
  43     private IMessageDispatchService mdService;
  44     private final AtomicLong xid;
  45     private final Map<Long, PortGrouping> physicalPorts;
  46     private final Map<Long, Boolean> portBandwidth;
  47     public static Cache<TransactionKey, Object> bulkTransactionCache = CacheBuilder.newBuilder().expireAfterWrite(10000, TimeUnit.MILLISECONDS).concurrencyLevel(1).build();
  48     private CompositeObjectRegistration<ModelDrivenSwitch> providerRegistration;
  49
  50
  51     /**
  52      * default ctor
  53      */
  54     public SessionContextOFImpl() {
  55         auxiliaryConductors = new ConcurrentHashMap<>();
  56         mdService = new MessageDispatchServiceImpl(this);
  57         xid = new AtomicLong();
  58         this.physicalPorts = new HashMap<Long, PortGrouping>();
  59         this.portBandwidth = new HashMap<Long, Boolean>();
  60     }
  61
  62     @Override
  63     public ConnectionConductor getPrimaryConductor() {
  64         return primaryConductor;
  65     }
  66
  67     @Override
  68     public ConnectionConductor getAuxiliaryConductor(
  69             SwitchConnectionDistinguisher auxiliaryKey) {
  70         return auxiliaryConductors.get(auxiliaryKey);
  71     }
  72
  73     @Override
  74     public void addAuxiliaryConductor(
  75             SwitchConnectionDistinguisher auxiliaryKey,
  76             ConnectionConductor conductor) {
  77         auxiliaryConductors.put(auxiliaryKey, conductor);
  78     }
  79
  80     @Override
  81     public Set<Entry<SwitchConnectionDistinguisher, ConnectionConductor>> getAuxiliaryConductors() {
  82         return Collections.unmodifiableSet(auxiliaryConductors.entrySet());
  83     }
  84
  85     @Override
  86     public Cache<TransactionKey, Object> getbulkTransactionCache() {
  87         return bulkTransactionCache;
  88     }
  89
  90     @Override
  91     public GetFeaturesOutput getFeatures() {
  92         return features;
  93     }
  94
  95     /**
  96      * @param features
  97      *            the features to set
  98      */
  99     public void setFeatures(GetFeaturesOutput features) {
 100         this.features = features;
 101     }
 102
 103     /**
 104      * @param primaryConductor
 105      *            the primaryConductor to set
 106      */
 107     public void setPrimaryConductor(ConnectionConductor primaryConductor) {
 108         this.primaryConductor = primaryConductor;
 109     }
 110
 111     @Override
 112     public ConnectionConductor removeAuxiliaryConductor(
 113             SwitchConnectionDistinguisher connectionCookie) {
 114         return auxiliaryConductors.remove(connectionCookie);
 115     }
 116
 117     @Override
 118     public boolean isValid() {
 119         return valid;
 120     }
 121
 122     @Override
 123     public void setValid(boolean valid) {
 124         this.valid = valid;
 125     }
 126
 127     /**
 128      * @param sessionKey the sessionKey to set
 129      */
 130     public void setSessionKey(SwitchConnectionDistinguisher sessionKey) {
 131         this.sessionKey = sessionKey;
 132     }
 133
 134     @Override
 135     public SwitchConnectionDistinguisher getSessionKey() {
 136         return sessionKey;
 137     }
 138
 139     @Override
 140     public IMessageDispatchService getMessageDispatchService() {
 141         return mdService;
 142     }
 143
 144     @Override
 145     public Long getNextXid() {
 146         return xid.incrementAndGet();
 147     }
 148
 149     @Override
 150     public Map<Long, PortGrouping> getPhysicalPorts() {
 151         return this.physicalPorts;
 152     }
 153
 154     @Override
 155     public Map<Long, Boolean> getPortsBandwidth() {
 156         return this.portBandwidth;
 157     }
 158
 159     @Override
 160     public Set<Long> getPorts() {
 161         return this.physicalPorts.keySet();
 162     }
 163
 164     @Override
 165     public PortGrouping getPhysicalPort(Long portNumber) {
 166         return this.physicalPorts.get(portNumber);
 167     }
 168
 169     @Override
 170     public Boolean getPortBandwidth(Long portNumber) {
 171         return this.portBandwidth.get(portNumber);
 172     }
 173
 174     @Override
 175     public boolean isPortEnabled(long portNumber) {
 176         return isPortEnabled(physicalPorts.get(portNumber));
 177     }
 178
 179     @Override
 180     public boolean isPortEnabled(PortGrouping port) {
 181         if (port == null) {
 182             return false;
 183         }
 184         if (port.getConfig().isPortDown()) {
 185             return false;
 186         }
 187         if (port.getState().isLinkDown()) {
 188             return false;
 189         }
 190         if (port.getState().isBlocked()) {
 191             return false;
 192         }
 193         return true;
 194     }
 195
 196     @Override
 197     public List<PortGrouping> getEnabledPorts() {
 198         List<PortGrouping> result = new ArrayList<PortGrouping>();
 199         synchronized (this.physicalPorts) {
 200             for (PortGrouping port : physicalPorts.values()) {
 201                 if (isPortEnabled(port)) {
 202                     result.add(port);
 203                 }
 204             }
 205         }
 206         return result;
 207     }
 208
 209     @Override
 210     public void setProviderRegistration(
 211             CompositeObjectRegistration<ModelDrivenSwitch> providerRegistration) {
 212                 this.providerRegistration = providerRegistration;
 213     }
 214
 215     @Override
 216     public CompositeObjectRegistration<ModelDrivenSwitch> getProviderRegistration() {
 217         return providerRegistration;
 218     }
 219 }