Blinker

@@ -37,6 +37,19 @@

       If this file does not exists, the number of simultaneous connections

       is not limited.

     </p>

+    <h3>Single Mode</h3>

+    <p>

+      In single mode, the operator connection splitter module makes sure that

+      all outgoing connections go to the same target module (.

+      The first connection works as usual.

+      Additional connections are directly forwarded to the module chosen

+      by the first connection.

+      If no module has been selected by the first connection, no further

+      incoming connections are accepted.

+      <br>

+      Single mode can be enabled by writing <code>true</code> to the file

+      <code>single</code>.

+    </p>

     <h3>Extensions / Phone Numbers</h3>

     <p>

       The virtual extensions (i.e. phone numbers) that can be called

@@ -51,6 +51,22 @@ bool OpMgr::close(const std::string &name)

   return true;

 }

+/**

+ * @brief check if operator interface will accept new connection

+ * @param[in] name operator interface to connect to

+ * @return if a new connection would be accepted

+ */

+bool OpMgr::canConnect(const std::string &name)

+{

+  // find requested interface

+  ReqIfMap::iterator itReqIf = m_reqIfs.find(name);

+  if (itReqIf == m_reqIfs.end())

+    return false; // not open

+

+  // check with server side if new connection is accepted

+  return itReqIf->second->acceptNewOpConn(name);

+}

+

 /**

  * @brief connect to operator interface

  * @param[in] name operator interface to connect to

@@ -52,6 +52,13 @@ public:

    */

   bool close(const std::string &name);

+  /**

+   * @brief check if operator interface will accept new connection

+   * @param[in] name operator interface to connect to

+   * @return if a new connection would be accepted

+   */

+  bool canConnect(const std::string &name);

+

   /**

    * @brief connect to operator interface

    * @param[in] name operator interface to connect to

@@ -6,6 +6,7 @@

 #include <map>

 #include <string>

+#include "BoolFile.h"

 #include "Directory.h"

 #include "File.h"

 #include "ListTracker.h"

@@ -36,6 +37,7 @@ OpSplitter::OpSplitter(const std::string &name, Mgrs &mgrs,

   Module(name, mgrs, dirBase),

   m_fileSound(dirBase.getFile("sound")),

   m_fileMaxConn(dirBase.getFile("maxconn")),

+  m_fileSingle(dirBase.getFile("single")),

   m_extListTracker(*this, dirBase.getSubdir("extensions"))

 {

   // load extensions

@@ -86,6 +88,10 @@ void OpSplitter::updateConfig()

   if (m_fileMaxConn.checkModified())

     m_fileMaxConn.update();

+  // single mode config file was modified -> re-read single mode config

+  if (m_fileSingle.checkModified())

+    m_fileSingle.update();

+

   // extensions update

   m_extListTracker.updateConfig();

 }

@@ -93,14 +99,24 @@ void OpSplitter::updateConfig()

 /// callback when requested time reached

 void OpSplitter::timeCall()

 {

+  // process pending actions for local connections

+  MapLocal::iterator it = m_mapLocal.begin();

+  while (it != m_mapLocal.end()) {

+    // close connection

+    if (it->second.m_close) {

+      MapLocal::iterator itDel = it;

+      ++it; // we have to increment ourself to make erasing in loop work

+      itDel->first->close();

+      m_mapLocal.erase(itDel);

+      continue; // it already incremented -> skip rest of loop

+    }

     // send sound play request on marked local operator connection

-  for (MapLocal::iterator it = m_mapLocal.begin();

-       it != m_mapLocal.end(); ++it) {

     if (it->second.m_sendPlay) {

       it->second.m_sendPlay = false;

       if (m_fileSound.m_valid)

         it->first->sendPlay(m_fileSound.m_obj.m_str);

     }

+    ++it;

   }

 }

@@ -115,7 +131,25 @@ bool OpSplitter::acceptNewOpConn(const std::string &name)

   if (m_fileMaxConn.m_valid &&

       m_mapLocal.size() + m_mapInOut.size() >= m_fileMaxConn.m_obj.m_uint)

     return false; // too many connection

+

+  // single mode

+  if (m_fileSingle.m_valid && m_fileSingle.m_obj.m_bool) {

+

+    // accept first connection

+    if (m_mapLocal.empty() && m_mapInOut.empty())

+      return true;

+

+    // no operator interface selected yet

+    if (m_singleOp.empty())

+      return false;

+

+    // additional connections: ask selected operator interface

+    return m_mgrs.m_opMgr.canConnect(m_singleOp);

+

+  } // if m_fileSingle

+

   return true;

+

   (void)name; // unused

 }

@@ -128,7 +162,29 @@ bool OpSplitter::acceptNewOpConn(const std::string &name)

  */

 void OpSplitter::newOpConn(const std::string &name, OpConn *pConn)

 {

-  // this is a new incoming connection -> make it a local connection

+  // this is a new incoming connection

+

+  // single mode and not first connection

+  if (m_fileSingle.m_valid && m_fileSingle.m_obj.m_bool) {

+    if (!m_mapLocal.empty() || !m_mapInOut.empty()) {

+

+      // try to open outgoiong operator connection to selected operator intf.

+      OpConn *pOutConn = m_mgrs.m_opMgr.connect(m_singleOp, this);

+      if (!pOutConn) {

+        // module is not ready for connection

+        newLocal(pConn, true); // make conn. a local conn. to be closed soon

+        return;

+      }

+

+      // establish connection forwarding

+      m_mapInOut[pConn] = pOutConn;

+      m_mapOutIn[pOutConn] = pConn;

+

+      return;

+    } // if !m_mapLocal.empty() ...

+  } // if m_fileSingle ...

+

+  // make connection a local connection

   newLocal(pConn);

   (void)name; // unused

@@ -208,15 +264,29 @@ void OpSplitter::opConnClose(OpConn *pConn)

     itInOut->second->close();

     m_mapOutIn.erase(itInOut->second);

     m_mapInOut.erase(itInOut);

+    if (m_mapInOut.empty()) // last connection closed -> no operator intf. sel.

+      m_singleOp.clear();

     return;

   }

-  // outgoing to incoming connection -> make incoming connection local

+  // outgoing to incoming connection

   MapOutIn::iterator itOutIn = m_mapOutIn.find(pConn);

   if (itOutIn != m_mapOutIn.end()) {

-    newLocal(itOutIn->second);

-    m_mapInOut.erase(itOutIn->second);

+    OpConn * pInConn = itOutIn->second;

+    m_mapInOut.erase(pInConn);

     m_mapOutIn.erase(itOutIn);

+    if (m_mapInOut.empty()) // last connection closed -> no operator intf. sel.

+      m_singleOp.clear();

+    // single mode and not last connection

+    if (m_fileSingle.m_valid && m_fileSingle.m_obj.m_bool) {

+      if (!m_mapLocal.empty() || !m_mapInOut.empty()) {

+        // close incoming connection as well

+        pInConn->close();

+        return;

+      }

+    }

+    // make incoming connection local

+    newLocal(pInConn);

     return;

   }

 }

@@ -224,13 +294,15 @@ void OpSplitter::opConnClose(OpConn *pConn)

 /**

  * @brief create new local connection

  * @param[in] pConn connection to make local

+ * @param[in] close if to close connection as soon as possible

  */

-void OpSplitter::newLocal(OpConn *pConn)

+void OpSplitter::newLocal(OpConn *pConn, bool close /* = false */)

 {

   // add connection to local connection map

   Local &local = m_mapLocal[pConn];

   local.m_number.clear(); // no extension dialed so far

-  local.m_sendPlay = true; // send play command

+  local.m_sendPlay = !close; // send play command if close not requested

+  local.m_close = close;

   m_mgrs.m_callMgr.requestTimeCall(this, Time::now());

 }

@@ -261,22 +333,14 @@ void OpSplitter::localKey(MapLocal::iterator itLocal, char key)

       break;

     // close local connection / call extension

     case '#':

-      if (itLocal->second.m_number.empty())

-        localClose(itLocal);

-      else

+      if (itLocal->second.m_number.empty()) {

+        itLocal->first->close();

+        m_mapLocal.erase(itLocal);

+      } else {

         callExtension(itLocal);

-      break;

       }

+      break;

   }

-

-/**

- * @brief close local connection

- * @param[in] itLocal local connection

- */

-void OpSplitter::localClose(MapLocal::iterator itLocal)

-{

-  itLocal->first->close();

-  m_mapLocal.erase(itLocal);

 }

 /**

@@ -293,10 +357,12 @@ void OpSplitter::callExtension(MapLocal::iterator itLocal)

     return;

   }

+  // save selected operator interface for single mode

+  m_singleOp = itExt->second;

+

   // try to open outgoiong operator connection to module

   OpConn *pOutConn = m_mgrs.m_opMgr.connect(itExt->second, this);

-  if (!pOutConn)

-  {

+  if (!pOutConn) {

     // module is not ready for connection

     itLocal->second.m_number.clear(); // begin new extension number

     return;

@@ -9,6 +9,7 @@

 #include <map>

 #include <string>

+#include "BoolFile.h"

 #include "Directory.h"

 #include "File.h"

 #include "ListTracker.h"

@@ -42,6 +43,7 @@ protected:

   struct Local {

     std::string m_number;   ///< extension number dialed so far

     bool        m_sendPlay; ///< if to send a play request

+    bool        m_close;    ///< if to close connection as soon as possible

   };

   /**

@@ -129,8 +131,9 @@ protected:

   /**

    * @brief create new local connection

    * @param[in] pConn connection to make local

+   * @param[in] close if to close connection as soon as possible

    */

-  void newLocal(OpConn *pConn);

+  void newLocal(OpConn *pConn, bool close = false);

   /**

    * @brief a key has been pressed for a local connection

@@ -139,12 +142,6 @@ protected:

    */

   void localKey(MapLocal::iterator itLocal, char key);

-  /**

-   * @brief close local connection

-   * @param[in] itLocal local connection

-   */

-  void localClose(MapLocal::iterator itLocal);

-

   /**

    * @brief call extension dialed over local connection

    * @param[in] itLocal local connection

@@ -154,6 +151,8 @@ protected:

 protected:

   NameFile       m_fileSound;      ///< file containing sound name

   UIntFile       m_fileMaxConn;    ///< file containing max. number of conn.

+  BoolFile       m_fileSingle;     ///< file containing single mode config

+  std::string    m_singleOp;       ///< operator intf. to call in single mode

   ExtListTracker m_extListTracker; ///< extension tracker

   ExtMap         m_extMap;         ///< map of extensions to call

   MapLocal       m_mapLocal;       ///< localy handled connections