Merge remote-tracking branch 'upstream/master' into network-indicator

akka-bbb-apps/run-dev.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+rm -rf src/main/resources
+cp -R src/universal/conf src/main/resources
+sbt run
+

akka-bbb-apps/src/main/scala/org/bigbluebutton/Boot.scala

@@ -1,17 +1,15 @@
 package org.bigbluebutton
 
-import org.bigbluebutton.common2.redis.RedisPublisher
+import org.bigbluebutton.common2.redis.{ MessageSender, RedisConfig, RedisPublisher }
 import org.bigbluebutton.core._
 import org.bigbluebutton.core.bus._
 import org.bigbluebutton.core.pubsub.senders.ReceivedJsonMsgHandlerActor
 import org.bigbluebutton.core2.AnalyticsActor
 import org.bigbluebutton.core2.FromAkkaAppsMsgSenderActor
 import org.bigbluebutton.endpoint.redis.AppsRedisSubscriberActor
 import org.bigbluebutton.endpoint.redis.RedisRecorderActor
-
 import akka.actor.ActorSystem
 import akka.event.Logging
-import org.bigbluebutton.common2.redis.MessageSender
 import org.bigbluebutton.common2.bus.IncomingJsonMessageBus
 
 object Boot extends App with SystemConfiguration {
@@ -28,17 +26,29 @@ object Boot extends App with SystemConfiguration {
 
   val outGW = new OutMessageGatewayImp(outBus2)
 
-  val redisPublisher = new RedisPublisher(system, "BbbAppsAkkaPub")
+  val redisPass = if (redisPassword != "") Some(redisPassword) else None
+  val redisConfig = RedisConfig(redisHost, redisPort, redisPass, redisExpireKey)
+
+  val redisPublisher = new RedisPublisher(
+    system,
+    "BbbAppsAkkaPub",
+    redisConfig
+  )
+
   val msgSender = new MessageSender(redisPublisher)
 
-  val redisRecorderActor = system.actorOf(RedisRecorderActor.props(system), "redisRecorderActor")
+  val redisRecorderActor = system.actorOf(
+    RedisRecorderActor.props(system, redisConfig),
+    "redisRecorderActor"
+  )
 
   recordingEventBus.subscribe(redisRecorderActor, outMessageChannel)
   val incomingJsonMessageBus = new IncomingJsonMessageBus
 
   val bbbMsgBus = new BbbMsgRouterEventBus
 
   val fromAkkaAppsMsgSenderActorRef = system.actorOf(FromAkkaAppsMsgSenderActor.props(msgSender))
+
   val analyticsActorRef = system.actorOf(AnalyticsActor.props())
   outBus2.subscribe(fromAkkaAppsMsgSenderActorRef, outBbbMsgMsgChannel)
   outBus2.subscribe(redisRecorderActor, recordServiceMessageChannel)
@@ -52,5 +62,17 @@ object Boot extends App with SystemConfiguration {
   val redisMessageHandlerActor = system.actorOf(ReceivedJsonMsgHandlerActor.props(bbbMsgBus, incomingJsonMessageBus))
   incomingJsonMessageBus.subscribe(redisMessageHandlerActor, toAkkaAppsJsonChannel)
 
-  val redisSubscriberActor = system.actorOf(AppsRedisSubscriberActor.props(system, incomingJsonMessageBus), "redis-subscriber")
+  val channelsToSubscribe = Seq(toAkkaAppsRedisChannel, fromVoiceConfRedisChannel)
+
+  val redisSubscriberActor = system.actorOf(
+    AppsRedisSubscriberActor.props(
+      system,
+      incomingJsonMessageBus,
+      redisConfig,
+      channelsToSubscribe,
+      Nil,
+      toAkkaAppsJsonChannel
+    ),
+    "redis-subscriber"
+  )
 }

akka-bbb-apps/src/main/scala/org/bigbluebutton/SystemConfiguration.scala

@@ -1,10 +1,10 @@
 package org.bigbluebutton
 
 import scala.util.Try
+import com.typesafe.config.ConfigFactory
 
-import org.bigbluebutton.common2.redis.RedisConfiguration
-
-trait SystemConfiguration extends RedisConfiguration {
+trait SystemConfiguration {
+  val config = ConfigFactory.load()
 
   lazy val bbbWebHost = Try(config.getString("services.bbbWebHost")).getOrElse("localhost")
   lazy val bbbWebPort = Try(config.getInt("services.bbbWebPort")).getOrElse(8888)
@@ -47,4 +47,28 @@ trait SystemConfiguration extends RedisConfiguration {
   lazy val endMeetingWhenNoMoreAuthedUsers = Try(config.getBoolean("apps.endMeetingWhenNoMoreAuthedUsers")).getOrElse(false)
   lazy val endMeetingWhenNoMoreAuthedUsersAfterMinutes = Try(config.getInt("apps.endMeetingWhenNoMoreAuthedUsersAfterMinutes")).getOrElse(2)
   lazy val multiUserWhiteboardDefault = Try(config.getBoolean("whiteboard.multiUserDefault")).getOrElse(false)
+
+  // Redis server configuration
+  lazy val redisHost = Try(config.getString("redis.host")).getOrElse("127.0.0.1")
+  lazy val redisPort = Try(config.getInt("redis.port")).getOrElse(6379)
+  lazy val redisPassword = Try(config.getString("redis.password")).getOrElse("")
+  lazy val redisExpireKey = Try(config.getInt("redis.keyExpiry")).getOrElse(1209600)
+
+  // Redis channels
+  lazy val toAkkaAppsRedisChannel = Try(config.getString("redis.toAkkaAppsRedisChannel")).getOrElse("to-akka-apps-redis-channel")
+  lazy val fromAkkaAppsRedisChannel = Try(config.getString("redis.fromAkkaAppsRedisChannel")).getOrElse("from-akka-apps-redis-channel")
+
+  lazy val toVoiceConfRedisChannel = Try(config.getString("redis.toVoiceConfRedisChannel")).getOrElse("to-voice-conf-redis-channel")
+  lazy val fromVoiceConfRedisChannel = Try(config.getString("redis.fromVoiceConfRedisChannel")).getOrElse("from-voice-conf-redis-channel")
+
+  lazy val fromAkkaAppsWbRedisChannel = Try(config.getString("redis.fromAkkaAppsWbRedisChannel")).getOrElse("from-akka-apps-wb-redis-channel")
+  lazy val fromAkkaAppsChatRedisChannel = Try(config.getString("redis.fromAkkaAppsChatRedisChannel")).getOrElse("from-akka-apps-chat-redis-channel")
+  lazy val fromAkkaAppsPresRedisChannel = Try(config.getString("redis.fromAkkaAppsPresRedisChannel")).getOrElse("from-akka-apps-pres-redis-channel")
+
+  lazy val fromBbbWebRedisChannel = Try(config.getString("redis.fromBbbWebRedisChannel")).getOrElse("from-bbb-web-redis-channel")
+
+  lazy val toAkkaTranscodeRedisChannel = Try(config.getString("redis.toAkkaTranscodeRedisChannel")).getOrElse("bigbluebutton:to-bbb-transcode:system")
+  lazy val fromAkkaTranscodeRedisChannel = Try(config.getString("redis.fromAkkaTranscodeRedisChannel")).getOrElse("bigbluebutton:from-bbb-transcode:system")
+  lazy val toAkkaTranscodeJsonChannel = Try(config.getString("eventBus.toAkkaTranscodeJsonChannel")).getOrElse("to-akka-transcode-json-channel")
+  lazy val fromAkkaTranscodeJsonChannel = Try(config.getString("eventBus.fromAkkaTranscodeJsonChannel")).getOrElse("from-akka-transcode-json-channel")
 }

akka-bbb-apps/src/main/scala/org/bigbluebutton/core/apps/users/ChangeLockSettingsInMeetingCmdMsgHdlr.scala

@@ -24,6 +24,7 @@ trait ChangeLockSettingsInMeetingCmdMsgHdlr extends RightsManagementTrait {
         disableMic = msg.body.disableMic,
         disablePrivChat = msg.body.disablePrivChat,
         disablePubChat = msg.body.disablePubChat,
+        disableNote = msg.body.disableNote,
         lockedLayout = msg.body.lockedLayout,
         lockOnJoin = msg.body.lockOnJoin,
         lockOnJoinConfigurable = msg.body.lockOnJoinConfigurable
@@ -48,6 +49,7 @@ trait ChangeLockSettingsInMeetingCmdMsgHdlr extends RightsManagementTrait {
           disableMic = settings.disableMic,
           disablePrivChat = settings.disablePrivChat,
           disablePubChat = settings.disablePubChat,
+          disableNote = settings.disableNote,
           lockedLayout = settings.lockedLayout,
           lockOnJoin = settings.lockOnJoin,
           lockOnJoinConfigurable = settings.lockOnJoinConfigurable,

akka-bbb-apps/src/main/scala/org/bigbluebutton/core/apps/users/GetLockSettingsReqMsgHdlr.scala

@@ -18,7 +18,7 @@ trait GetLockSettingsReqMsgHdlr {
     val body = GetLockSettingsRespMsgBody(
       disableCam = settings.disableCam,
       disableMic = settings.disableMic, disablePrivChat = settings.disablePrivChat,
-      disablePubChat = settings.disablePubChat, lockedLayout = settings.lockedLayout,
+      disablePubChat = settings.disablePubChat, disableNote = settings.disableNote, lockedLayout = settings.lockedLayout,
       lockOnJoin = settings.lockOnJoin, lockOnJoinConfigurable = settings.lockOnJoinConfigurable
     )
     val header = BbbClientMsgHeader(GetLockSettingsRespMsg.NAME, meetingId, requestedBy)

akka-bbb-apps/src/main/scala/org/bigbluebutton/core/running/MeetingActor.scala

@@ -233,6 +233,7 @@ class MeetingActor(
       disableMic = lockSettingsProp.disableMic,
       disablePrivChat = lockSettingsProp.disablePrivateChat,
       disablePubChat = lockSettingsProp.disablePublicChat,
+      disableNote = lockSettingsProp.disableNote,
       lockedLayout = lockSettingsProp.lockedLayout,
       lockOnJoin = lockSettingsProp.lockOnJoin,
       lockOnJoinConfigurable = lockSettingsProp.lockOnJoinConfigurable

akka-bbb-apps/src/main/scala/org/bigbluebutton/core2/MeetingStatus2x.scala

@@ -9,6 +9,7 @@ case class Permissions(
     disableMic:             Boolean = false,
     disablePrivChat:        Boolean = false,
     disablePubChat:         Boolean = false,
+    disableNote:            Boolean = false,
     lockedLayout:           Boolean = false,
     lockOnJoin:             Boolean = true,
     lockOnJoinConfigurable: Boolean = false

akka-bbb-apps/src/main/scala/org/bigbluebutton/endpoint/redis/AkkaAppsRedisSubscriberActor.scala

@@ -1,34 +1,47 @@
 package org.bigbluebutton.endpoint.redis
 
-import org.bigbluebutton.SystemConfiguration
 import org.bigbluebutton.common2.bus.IncomingJsonMessageBus
-import org.bigbluebutton.common2.redis.{ RedisSubscriber, RedisSubscriberProvider }
-
+import org.bigbluebutton.common2.redis.{ RedisConfig, RedisSubscriber, RedisSubscriberProvider }
 import akka.actor.ActorSystem
 import akka.actor.Props
 
-object AppsRedisSubscriberActor extends RedisSubscriber {
-
-  val channels = Seq(toAkkaAppsRedisChannel, fromVoiceConfRedisChannel)
-  val patterns = Seq("bigbluebutton:to-bbb-apps:*", "bigbluebutton:from-voice-conf:*", "bigbluebutton:from-bbb-transcode:*")
-
-  def props(system: ActorSystem, jsonMsgBus: IncomingJsonMessageBus): Props =
+object AppsRedisSubscriberActor {
+  def props(
+      system:              ActorSystem,
+      jsonMsgBus:          IncomingJsonMessageBus,
+      redisConfig:         RedisConfig,
+      channelsToSubscribe: Seq[String],
+      patternsToSubscribe: Seq[String],
+      forwardMsgToChannel: String
+  ): Props =
     Props(
       classOf[AppsRedisSubscriberActor],
-      system, jsonMsgBus,
-      redisHost, redisPort,
-      channels, patterns
+      system,
+      jsonMsgBus,
+      redisConfig,
+      channelsToSubscribe,
+      patternsToSubscribe,
+      forwardMsgToChannel
     ).withDispatcher("akka.redis-subscriber-worker-dispatcher")
 }
 
 class AppsRedisSubscriberActor(
-    system:     ActorSystem,
-    jsonMsgBus: IncomingJsonMessageBus,
-    redisHost:  String, redisPort: Int,
-    channels: Seq[String] = Nil, patterns: Seq[String] = Nil
+    system:              ActorSystem,
+    jsonMsgBus:          IncomingJsonMessageBus,
+    redisConfig:         RedisConfig,
+    channelsToSubscribe: Seq[String],
+    patternsToSubscribe: Seq[String],
+    forwardMsgToChannel: String
 )
-  extends RedisSubscriberProvider(system, "BbbAppsAkkaSub", channels, patterns, jsonMsgBus) with SystemConfiguration {
+  extends RedisSubscriberProvider(
+    system,
+    "BbbAppsAkkaSub",
+    channelsToSubscribe,
+    patternsToSubscribe,
+    jsonMsgBus,
+    redisConfig
+  ) {
 
-  addListener(toAkkaAppsJsonChannel)
+  addListener(forwardMsgToChannel)
   subscribe()
 }

akka-bbb-apps/src/main/scala/org/bigbluebutton/endpoint/redis/RedisRecorderActor.scala

@@ -2,26 +2,37 @@ package org.bigbluebutton.endpoint.redis
 
 import scala.collection.immutable.StringOps
 import scala.collection.JavaConverters._
-
 import org.bigbluebutton.SystemConfiguration
 import org.bigbluebutton.common2.msgs._
-import org.bigbluebutton.common2.redis.RedisStorageProvider
+import org.bigbluebutton.common2.redis.{ RedisConfig, RedisStorageProvider }
 import org.bigbluebutton.core.apps.groupchats.GroupChatApp
 import org.bigbluebutton.core.record.events._
-
 import akka.actor.Actor
 import akka.actor.ActorLogging
 import akka.actor.ActorSystem
 import akka.actor.Props
 
 object RedisRecorderActor {
-  def props(system: ActorSystem): Props = Props(classOf[RedisRecorderActor], system)
+  def props(
+      system:      ActorSystem,
+      redisConfig: RedisConfig
+  ): Props =
+    Props(
+      classOf[RedisRecorderActor],
+      system,
+      redisConfig
+    )
 }
 
-class RedisRecorderActor(system: ActorSystem)
-  extends RedisStorageProvider(system, "BbbAppsAkkaRecorder")
-  with SystemConfiguration
-  with Actor with ActorLogging {
+class RedisRecorderActor(
+    system:      ActorSystem,
+    redisConfig: RedisConfig
+)
+  extends RedisStorageProvider(
+    system,
+    "BbbAppsAkkaRecorder",
+    redisConfig
+  ) with Actor with ActorLogging {
 
   private def record(session: String, message: java.util.Map[java.lang.String, java.lang.String]): Unit = {
     redis.recordAndExpire(session, message)