openvidu-server: Session ReadWriteLock for closing operation

openvidu-server/src/main/java/io/openvidu/server/core/Session.java

@@ -23,6 +23,8 @@ import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.function.Function;
 
 import com.google.gson.JsonArray;
@@ -51,6 +53,17 @@ public class Session implements SessionInterface {
 	protected volatile boolean closed = false;
 	protected AtomicInteger activePublishers = new AtomicInteger(0);
 
+	/**
+	 * This lock protects the following operations with read lock: [REST API](POST
+	 * /api/tokens, POST /sessions/{sessionId}/connection), [RPC](joinRoom).
+	 * 
+	 * All of them get it with tryLock, immediately failing if written locked
+	 * 
+	 * Lock is written-locked upon session close up. That is: everywhere in the code
+	 * calling method SessionManager#closeSessionAndEmptyCollections (5 times)
+	 */
+	public ReadWriteLock closingLock = new ReentrantReadWriteLock();
+
 	public final AtomicBoolean recordingManuallyStopped = new AtomicBoolean(false);
 
 	public Session(Session previousSession) {

openvidu-server/src/main/java/io/openvidu/server/core/SessionManager.java

@@ -489,7 +489,15 @@ public abstract class SessionManager {
 			// This code should only be executed when there were no participants connected
 			// to the session. That is: if the session was in the automatic recording stop
 			// timeout with INDIVIDUAL recording (no docker participant connected)
+			try {
+				session.closingLock.writeLock().lock();
+				if (session.isClosed()) {
+					return;
+				}
 				this.closeSessionAndEmptyCollections(session, reason, true);
+			} finally {
+				session.closingLock.writeLock().unlock();
+			}
 		}
 	}
 
@@ -500,13 +508,6 @@ public abstract class SessionManager {
 			recordingManager.stopRecording(session, null, RecordingManager.finalReason(reason));
 		}
 
-		if (EndReason.automaticStop.equals(reason) && !session.getParticipants().isEmpty()
-				&& !session.onlyRecorderParticipant()) {
-			log.warn(
-					"Some user connected to the session between automatic recording stop and session close up. Canceling session close up");
-			return;
-		}
-
 		final String mediaNodeId = session.getMediaNodeId();
 
 		if (session.close(reason)) {

openvidu-server/src/main/java/io/openvidu/server/kurento/core/KurentoSessionManager.java

@@ -89,7 +89,7 @@ public class KurentoSessionManager extends SessionManager {
 
 			if (kSession == null) {
 				// First user connecting to the session
-				Session sessionNotActive = sessionsNotActive.remove(sessionId);
+				Session sessionNotActive = sessionsNotActive.get(sessionId);
 
 				if (sessionNotActive == null && this.isInsecureParticipant(participant.getParticipantPrivateId())) {
 					// Insecure user directly call joinRoom RPC method, without REST API use
@@ -213,10 +213,19 @@ public class KurentoSessionManager extends SessionManager {
 							this.openviduConfig.getOpenviduRecordingAutostopTimeout(), sessionId);
 					recordingManager.initAutomaticRecordingStopThread(session);
 				} else {
+					try {
+						session.closingLock.writeLock().lock();
+						if (session.isClosed()) {
+							return false;
+						}
 						log.info("No more participants in session '{}', removing it and closing it", sessionId);
 						this.closeSessionAndEmptyCollections(session, reason, true);
 						sessionClosedByLastParticipant = true;
 						showTokens();
+					} finally {
+						session.closingLock.writeLock().unlock();
+					}
+
 				}
 			} else if (remainingParticipants.size() == 1 && openviduConfig.isRecordingModuleEnabled()
 					&& MediaMode.ROUTED.equals(session.getSessionProperties().mediaMode())
@@ -514,6 +523,7 @@ public class KurentoSessionManager extends SessionManager {
 		}
 		session = new KurentoSession(sessionNotActive, kms, kurentoSessionEventsHandler, kurentoEndpointConfig);
 
+		sessionsNotActive.remove(session.getSessionId());
 		KurentoSession oldSession = (KurentoSession) sessions.putIfAbsent(session.getSessionId(), session);
 		if (oldSession != null) {
 			log.warn("Session '{}' has just been created by another thread", session.getSessionId());

openvidu-server/src/main/java/io/openvidu/server/recording/service/RecordingManager.java

@@ -482,6 +482,14 @@ public class RecordingManager {
 						recordingId, this.openviduConfig.getOpenviduRecordingAutostopTimeout());
 
 				if (this.automaticRecordingStopThreads.remove(session.getSessionId()) != null) {
+
+					boolean alreadyUnlocked = false;
+					try {
+						session.closingLock.writeLock().lock();
+						if (session.isClosed()) {
+							return;
+						}
+
 						if (session.getParticipants().size() == 0 || session.onlyRecorderParticipant()) {
 							// Close session if there are no participants connected (RECORDER does not
 							// count) and publishing
@@ -491,11 +499,18 @@ public class RecordingManager {
 							sessionManager.showTokens();
 						} else {
 							// There are users connected, but no one is publishing
+							session.closingLock.writeLock().unlock(); // We don't need the lock if session's not closing
+							alreadyUnlocked = true;
 							log.info(
 									"Automatic stopping recording {}. There are users connected to session {}, but no one is publishing",
 									recordingId, session.getSessionId());
 							this.stopRecording(session, recordingId, EndReason.automaticStop);
 						}
+					} finally {
+						if (!alreadyUnlocked) {
+							session.closingLock.writeLock().unlock();
+						}
+					}
 				} else {
 					// This code shouldn't be reachable
 					log.warn("Recording {} was already automatically stopped by a previous thread", recordingId);
@@ -510,6 +525,11 @@ public class RecordingManager {
 		ScheduledFuture<?> future = this.automaticRecordingStopThreads.remove(session.getSessionId());
 		if (future != null) {
 			boolean cancelled = future.cancel(false);
+			try {
+				session.closingLock.writeLock().lock();
+				if (session.isClosed()) {
+					return false;
+				}
 				if (session.getParticipants().size() == 0 || session.onlyRecorderParticipant()) {
 					// Close session if there are no participants connected (except for RECORDER).
 					// This code will only be executed if recording is manually stopped during the
@@ -521,6 +541,9 @@ public class RecordingManager {
 					sessionManager.showTokens();
 				}
 				return cancelled;
+			} finally {
+				session.closingLock.writeLock().unlock();
+			}
 		} else {
 			return true;
 		}

openvidu-server/src/main/java/io/openvidu/server/rest/SessionRestController.java

@@ -223,9 +223,17 @@ public class SessionRestController {
 
 		Session sessionNotActive = this.sessionManager.getSessionNotActive(sessionId);
 		if (sessionNotActive != null) {
+			try {
+				sessionNotActive.closingLock.writeLock().lock();
+				if (sessionNotActive.isClosed()) {
+					return new ResponseEntity<>(HttpStatus.NOT_FOUND);
+				}
 				this.sessionManager.closeSessionAndEmptyCollections(sessionNotActive, EndReason.sessionClosedByServer,
 						true);
 				return new ResponseEntity<>(HttpStatus.NO_CONTENT);
+			} finally {
+				sessionNotActive.closingLock.writeLock().unlock();
+			}
 		} else {
 			return new ResponseEntity<>(HttpStatus.NOT_FOUND);
 		}
@@ -310,7 +318,8 @@ public class SessionRestController {
 					HttpStatus.BAD_REQUEST);
 		}
 
-		if (this.sessionManager.getSessionWithNotActive(sessionId) == null) {
+		final Session session = this.sessionManager.getSessionWithNotActive(sessionId);
+		if (session == null) {
 			return this.generateErrorResponse("Session " + sessionId + " not found", "/api/tokens",
 					HttpStatus.NOT_FOUND);
 		}
@@ -350,6 +359,9 @@ public class SessionRestController {
 
 		metadata = (metadata != null) ? metadata : "";
 
+		// While closing a session tokens can't be generated
+		if (session.closingLock.readLock().tryLock()) {
+			try {
 				String token = sessionManager.newToken(sessionId, role, metadata, kurentoTokenOptions);
 
 				JsonObject responseJson = new JsonObject();
@@ -387,6 +399,14 @@ public class SessionRestController {
 					responseJson.add("kurentoOptions", kurentoOptsResponse);
 				}
 				return new ResponseEntity<>(responseJson.toString(), getResponseHeaders(), HttpStatus.OK);
+			} finally {
+				session.closingLock.readLock().unlock();
+			}
+		} else {
+			log.error("Session {} is in the process of closing. Token couldn't be generated", sessionId);
+			return this.generateErrorResponse("Session " + sessionId + " not found", "/api/tokens",
+					HttpStatus.NOT_FOUND);
+		}
 	}
 
 	@RequestMapping(value = "/recordings/start", method = RequestMethod.POST)
@@ -717,7 +737,12 @@ public class SessionRestController {
 				videoActive, typeOfVideo, frameRate, videoDimensions, null, false, rtspUri, adaptativeBitrate,
 				onlyPlayWithSubscribers);
 
+		// While closing a session IP cameras can't be published
+		if (session.closingLock.readLock().tryLock()) {
 			try {
+				if (session.isClosed()) {
+					return new ResponseEntity<>(HttpStatus.NOT_FOUND);
+				}
 				Participant ipcamParticipant = this.sessionManager.publishIpcam(session, mediaOptions, data);
 				return new ResponseEntity<>(ipcamParticipant.toJson().toString(), getResponseHeaders(), HttpStatus.OK);
 			} catch (MalformedURLException e) {
@@ -726,6 +751,11 @@ public class SessionRestController {
 			} catch (Exception e) {
 				return this.generateErrorResponse(e.getMessage(), "/api/sessions/" + sessionId + "/connection",
 						HttpStatus.INTERNAL_SERVER_ERROR);
+			} finally {
+				session.closingLock.readLock().unlock();
+			}
+		} else {
+			return new ResponseEntity<>(HttpStatus.NOT_FOUND);
 		}
 	}
 

openvidu-server/src/main/java/io/openvidu/server/rpc/RpcHandler.java

@@ -245,10 +245,14 @@ public class RpcHandler extends DefaultJsonRpcHandler<JsonObject> {
 
 				Token tokenObj = sessionManager.consumeToken(sessionId, participantPrivatetId, token);
 				Participant participant;
+				io.openvidu.server.core.Session session = sessionManager.getSessionWithNotActive(sessionId);
 
+				// While closing a session users can't join
+				if (session.closingLock.readLock().tryLock()) {
+					try {
 						if (generateRecorderParticipant) {
-					participant = sessionManager.newRecorderParticipant(sessionId, participantPrivatetId, tokenObj,
+							participant = sessionManager.newRecorderParticipant(sessionId, participantPrivatetId,
-							clientMetadata);
+									tokenObj, clientMetadata);
 						} else {
 							participant = sessionManager.newParticipant(sessionId, participantPrivatetId, tokenObj,
 									clientMetadata, location, platform,
@@ -258,6 +262,16 @@ public class RpcHandler extends DefaultJsonRpcHandler<JsonObject> {
 						rpcConnection.setSessionId(sessionId);
 						sessionManager.joinRoom(participant, sessionId, request.getId());
 
+					} finally {
+						session.closingLock.readLock().unlock();
+					}
+				} else {
+					log.error(
+							"ERROR: The session {} is in the process of closing while participant {} (privateId) was joining",
+							sessionId, participantPrivatetId);
+					throw new OpenViduException(Code.ROOM_CLOSED_ERROR_CODE,
+							"Unable to join the session. Session " + sessionId + " was in the process of closing");
+				}
 			} else {
 				log.error("ERROR: Metadata format set in client-side is incorrect");
 				throw new OpenViduException(Code.USER_METADATA_FORMAT_INVALID_ERROR_CODE,