import java.util.concurrent.ConcurrentHashMap;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.openflowplugin.api.openflow.md.core.ConnectionConductor;
+import org.opendaylight.openflowplugin.api.openflow.md.core.IMDMessageTranslator;
import org.opendaylight.openflowplugin.api.openflow.md.core.SwitchConnectionDistinguisher;
import org.opendaylight.openflowplugin.api.openflow.md.core.TranslatorKey;
-import org.opendaylight.openflowplugin.api.statistics.MessageSpy;
-import org.opendaylight.openflowplugin.openflow.md.core.ConnectionConductor;
-import org.opendaylight.openflowplugin.openflow.md.core.IMDMessageTranslator;
-import org.opendaylight.openflowplugin.openflow.md.core.extension.ExtensionConverterProvider;
-import org.opendaylight.openflowplugin.openflow.md.queue.PopListener;
+import org.opendaylight.openflowplugin.api.openflow.md.core.session.SessionContext;
+import org.opendaylight.openflowplugin.api.openflow.md.core.session.SessionListener;
+import org.opendaylight.openflowplugin.api.openflow.md.core.session.SwitchSessionKeyOF;
+import org.opendaylight.openflowplugin.api.openflow.md.queue.PopListener;
+import org.opendaylight.openflowplugin.api.openflow.statistics.MessageSpy;
+import org.opendaylight.openflowplugin.extension.api.core.extension.ExtensionConverterProvider;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OfHeader;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.concepts.util.ListenerRegistry;
+import org.opendaylight.yangtools.util.ListenerRegistry;
import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.slf4j.Logger;
/**
* @author mirehak
*/
-public class SessionManagerOFImpl implements SessionManager {
+public class SessionManagerOFImpl implements ConjunctSessionManager {
protected static final Logger LOG = LoggerFactory.getLogger(SessionManagerOFImpl.class);
private static SessionManagerOFImpl instance;
/**
* @return singleton instance
*/
- public static SessionManager getInstance() {
+ public static ConjunctSessionManager getInstance() {
if (instance == null) {
synchronized (SessionContextOFImpl.class) {
if (instance == null) {
}
/**
- * close and release singleton instace
+ * close and release singleton instance
*/
public static void releaseInstance() {
if (instance != null) {
public void invalidateSessionContext(SwitchSessionKeyOF sessionKey) {
SessionContext context = getSessionContext(sessionKey);
if (context == null) {
- LOG.warn("context for invalidation not found");
+ LOG.info("context for invalidation not found");
} else {
synchronized (context) {
- for (Entry<SwitchConnectionDistinguisher, ConnectionConductor> auxEntry : context.getAuxiliaryConductors()) {
- invalidateAuxiliary(sessionKey, auxEntry.getKey());
+ if (context.isValid()) {
+ for (Entry<SwitchConnectionDistinguisher, ConnectionConductor> auxEntry : context.getAuxiliaryConductors()) {
+ invalidateAuxiliary(sessionKey, auxEntry.getKey());
+ }
+ context.getPrimaryConductor().disconnect();
+ context.setValid(false);
+ removeSessionContext(context);
+ // TODO:: notify listeners
+ } else {
+ LOG.warn("Ignore invalid session context: {}",
+ Arrays.toString(sessionKey.getId()));
}
- context.getPrimaryConductor().disconnect();
- context.setValid(false);
- removeSessionContext(context);
- // TODO:: notify listeners
}
}
}
private void invalidateDeadSessionContext(SessionContext sessionContext) {
if (sessionContext == null) {
- LOG.warn("context for invalidation not found");
+ LOG.info("context for invalidation not found");
} else {
synchronized (sessionContext) {
- for (Entry<SwitchConnectionDistinguisher, ConnectionConductor> auxEntry : sessionContext
- .getAuxiliaryConductors()) {
- invalidateAuxiliary(sessionContext, auxEntry.getKey(), true);
+ if (sessionContext.isValid()) {
+ for (Entry<SwitchConnectionDistinguisher, ConnectionConductor> auxEntry : sessionContext
+ .getAuxiliaryConductors()) {
+ invalidateAuxiliary(sessionContext, auxEntry.getKey(), true);
+ }
+ sessionContext.setValid(false);
+ removeSessionContext(sessionContext);
+ // TODO:: notify listeners
+ } else {
+ LOG.warn("Ignore invalid dead session context: {}",
+ Arrays.toString(
+ sessionContext.getSessionKey().getId()));
}
- sessionContext.setValid(false);
- removeSessionContext(sessionContext);
- // TODO:: notify listeners
}
}
}
if (LOG.isDebugEnabled()) {
LOG.debug("removing session: {}", Arrays.toString(sessionContext.getSessionKey().getId()));
}
- sessionLot.remove(sessionContext.getSessionKey(), sessionContext);
- sessionNotifier.onSessionRemoved(sessionContext);
+ if (sessionLot.remove(sessionContext.getSessionKey(), sessionContext)) {
+ sessionNotifier.onSessionRemoved(sessionContext);
+ } else {
+ // This should never happen.
+ LOG.warn("Ignore session context that was already removed: {}",
+ Arrays.toString(sessionContext.getSessionKey().getId()));
+ }
}
@Override
synchronized (context) {
sessionLot.put(sessionKey, context);
sessionNotifier.onSessionAdded(sessionKey, context);
-
context.setValid(true);
}
}
+ @Override
+ public void setRole(SessionContext context) {
+ sessionNotifier.setRole(context);
+ }
@Override
public void invalidateAuxiliary(SwitchSessionKeyOF sessionKey,
SwitchConnectionDistinguisher connectionCookie) {
private static void invalidateAuxiliary(SessionContext context, SwitchConnectionDistinguisher connectionCookie,
boolean disconnect) {
if (context == null) {
- LOG.warn("context for invalidation not found");
+ LOG.info("context for invalidation not found");
} else {
ConnectionConductor auxiliaryConductor = context.removeAuxiliaryConductor(connectionCookie);
if (auxiliaryConductor == null) {
}
}
+ @Override
+ public void setRole(SessionContext context) {
+ for (ListenerRegistration<SessionListener> listener : sessionListeners) {
+ try {
+ listener.getInstance().setRole(context);
+ } catch (Exception e) {
+ LOG.error("Unhandled exeption occured while invoking setRole on listener", e);
+ }
+ }
+ }
+
@Override
public void onSessionRemoved(SessionContext context) {
for (ListenerRegistration<SessionListener> listener : sessionListeners) {
@Override
public void close() {
LOG.debug("close");
- sessionListeners = null;
synchronized (sessionLot) {
for (SessionContext sessionContext : sessionLot.values()) {
sessionContext.getPrimaryConductor().disconnect();
// TODO: handle timeouted shutdown
rpcPool.shutdown();
}
+
+ for (ListenerRegistration<SessionListener> listenerRegistration : sessionListeners) {
+ SessionListener listener = listenerRegistration.getInstance();
+ if (listener instanceof AutoCloseable) {
+ try {
+ ((AutoCloseable) listener).close();
+ } catch (Exception e) {
+ LOG.warn("closing of sessionListenerRegistration failed", e);
+ }
+ }
+ }
}
@Override
public ExtensionConverterProvider getExtensionConverterProvider() {
return extensionConverterProvider;
}
+
+ @Override
+ public Collection<SessionContext> getAllSessions() {
+ return sessionLot.values();
+ }
}