[asterisk-scf-commits] asterisk-scf/integration/bridging.git branch "partidextensionpoint" created.
Commits to the Asterisk SCF project code repositories
asterisk-scf-commits at lists.digium.com
Thu Sep 15 19:33:18 CDT 2011
branch "partidextensionpoint" has been created
at 3b7243f9ab78cf8b06d7bafed46718382704b6a8 (commit)
- Log -----------------------------------------------------------------
commit 3b7243f9ab78cf8b06d7bafed46718382704b6a8
Author: Ken Hunt <ken.hunt at digium.com>
Date: Thu Sep 15 19:32:15 2011 -0500
Extension point for modifying party id info.
diff --git a/src/BridgeImpl.cpp b/src/BridgeImpl.cpp
index 1563ec9..427729b 100755
--- a/src/BridgeImpl.cpp
+++ b/src/BridgeImpl.cpp
@@ -33,6 +33,7 @@
using namespace AsteriskSCF::System::Logging;
using namespace AsteriskSCF::SessionCommunications::V1;
using namespace AsteriskSCF::SessionCommunications::PartyIdentification::V1;
+using namespace AsteriskSCF::SessionCommunications::ExtensionPoints::V1;
using namespace AsteriskSCF::BridgeService;
using namespace AsteriskSCF::Replication::BridgeService::V1;
using namespace AsteriskSCF;
@@ -69,6 +70,7 @@ public:
BridgeImpl(const string& name, const Ice::ObjectAdapterPtr& objAdapter,
const vector<BridgeListenerPrx>& listeners,
const BridgeListenerMgrPtr& listenerMgr,
+ const BridgePartyIdHooksPtr& partyIdHooks,
const ReplicatorSmartPrx& replicator,
const BridgeStateItemPtr& state,
const Logger& logger);
@@ -116,6 +118,11 @@ public:
void getAddSessionsTasks(QueuedTasks& tasks, const SessionSeq& sessions);
+ BridgePartyIdHooksPtr getPartyIdHooks()
+ {
+ return mPartyIdHooks;
+ }
+
BridgeCookies getCookies()
{
BridgeCookies result;
@@ -126,6 +133,9 @@ public:
return result;
}
+ void updateConnectedLine(const SessionWrapperPtr& sourceSession, const ConnectedLinePtr& connectedLine);
+ void redirectingUpdated(const SessionWrapperPtr& sourceSession, const RedirectingPtr& redirecting);
+
private:
boost::shared_mutex mLock;
@@ -149,6 +159,7 @@ private:
Ice::ObjectAdapterPtr mObjAdapter;
BridgeListenerMgrPtr mListeners;
+ BridgePartyIdHooksPtr mPartyIdHooks;
ReplicatorSmartPrx mReplicator;
//
@@ -256,6 +267,273 @@ private:
};
typedef IceUtil::Handle<SessionsTracker> SessionsTrackerPtr;
+
+/**
+ * Forwards the redirecting record for the specified session
+ * to every other session in the bridge. Applies the
+ * ForwardingRedirecting hooks to the Redirecting record
+ * in the process.
+ *
+ * Note: For now we forward the Redirecting record
+ * without considering whether there are more then two
+ * sessions in the bridge. The API may need a more complex
+ * class than Redirecting to push the Redirecting state
+ * of all Sessions in the bridge.
+ */
+class ForwardRedirectingUpdatedTask : public QueuedTask
+{
+public:
+ ForwardRedirectingUpdatedTask(const BridgeImplPtr& bridge,
+ const SessionWrapperPtr& sourceSession,
+ const RedirectingPtr& redirecting,
+ const Logger& logger) :
+ QueuedTask("ForwardRedirectingUpdatedTask"),
+ mBridge(bridge),
+ mSourceSession(sourceSession),
+ mRedirecting(redirecting),
+ mLogger(logger)
+ {
+ }
+
+protected:
+ bool executeImpl()
+ {
+ try
+ {
+ mLogger(Debug) << FUNLOG;
+
+ BridgePartyIdHooksPtr partyIdHooks = mBridge->getPartyIdHooks();
+
+ // Forward the ConnectedLine to each bridged session.
+ SessionSeq sessions = mBridge->getSessions()->getSessionSeq();
+ for(SessionSeq::iterator i = sessions.begin();
+ i != sessions.end(); ++i)
+ {
+ if ((*i)->ice_getIdentity() == mSourceSession->getSession()->ice_getIdentity())
+ {
+ continue;
+ }
+
+ SessionWrapperPtr destSessionWrapper = mBridge->getSessions()->getSession(*i);
+ forward(destSessionWrapper, mRedirecting);
+ }
+
+ }
+ catch (const std::exception e)
+ {
+ mLogger(Debug) << FUNLOG << " : " << e.what();
+ }
+
+ return true;
+ }
+
+ void forward(const SessionWrapperPtr destinationSession, const RedirectingPtr& redirecting)
+ {
+ try
+ {
+ mLogger(Debug) << FUNLOG;
+
+ RedirectingPtr currentRedirecting = redirecting;
+ RedirectingPtr destSpecificRedirecting = redirecting;
+
+ BridgePartyIdHooksPtr partyIdHooks = mBridge->getPartyIdHooks();
+
+ // Allow the ForwardingRedirectingPartyId hooks to alter the Redirecting record.
+ for(vector<ForwardingRedirectingPartyIdHookPrx>::const_iterator i = partyIdHooks->getForwardingRedirectingPartyIdHooks().begin();
+ i != partyIdHooks->getForwardingRedirectingPartyIdHooks().end(); ++i)
+ {
+ AsteriskSCF::System::Hook::V1::HookResult hookResult = (*i)->modifyForwardingRedirecting(mSourceSession->getSession(),
+ destinationSession->getSession(),
+ currentRedirecting, destSpecificRedirecting);
+
+ if (hookResult.status == AsteriskSCF::System::Hook::V1::Succeeded)
+ {
+ currentRedirecting = destSpecificRedirecting;
+ }
+ }
+
+ // Forward the info via the SessionController for this session.
+ destinationSession->getSessionController()->redirectingUpdated(currentRedirecting);
+ }
+ catch (const std::exception e)
+ {
+ mLogger(Debug) << FUNLOG << " : " << e.what();
+ }
+ }
+
+private:
+ BridgeImplPtr mBridge;
+ SessionWrapperPtr mSourceSession;
+ RedirectingPtr mRedirecting;
+ Logger mLogger;
+};
+
+/**
+ * Sends the cached ConnectedLine info for the specified session
+ * to every other session in the bridge. Applies the
+ * ForwardingConnectedLine hooks to the ConnectedLine record
+ * in the process.
+ *
+ * Note: For now we forward the ConnectedLine record
+ * without considering whether there are more then two
+ * sessions in the bridge. The API may need a more complex
+ * class than ConnectedLine to push the state
+ * of more than one Session.
+ */
+class ForwardConnectedLineTask : public QueuedTask
+{
+public:
+ ForwardConnectedLineTask(const BridgeImplPtr& bridge,
+ const SessionWrapperPtr& sourceSession,
+ const Logger& logger) :
+ QueuedTask("ForwardConnectedLineTask"),
+ mBridge(bridge),
+ mSourceSession(sourceSession),
+ mLogger(logger)
+ {
+ }
+
+protected:
+ bool executeImpl()
+ {
+ try
+ {
+ mLogger(Debug) << FUNLOG;
+
+ ConnectedLinePtr currentConnectedLine;
+ bool isSet = mSourceSession->getConnectedLine(currentConnectedLine);
+
+ if (!isSet)
+ {
+ mLogger(Error) << "ConnectedLine not cached for forwarding. " ;
+ return true;
+ }
+
+ // Forward the ConnectedLine to each bridged session.
+ SessionSeq sessions = mBridge->getSessions()->getSessionSeq();
+ for(SessionSeq::iterator i = sessions.begin();
+ i != sessions.end(); ++i)
+ {
+ if ((*i)->ice_getIdentity() == mSourceSession->getSession()->ice_getIdentity())
+ {
+ continue;
+ }
+
+ SessionWrapperPtr destSessionWrapper = mBridge->getSessions()->getSession(*i);
+ forward(destSessionWrapper, currentConnectedLine);
+ }
+
+ }
+ catch (const std::exception e)
+ {
+ mLogger(Debug) << FUNLOG << " : " << e.what();
+ }
+
+ return true;
+ }
+
+ void forward(const SessionWrapperPtr destinationSession, const ConnectedLinePtr& connectedLine)
+ {
+ try
+ {
+ mLogger(Debug) << FUNLOG;
+
+ ConnectedLinePtr currentConnectedLine = connectedLine;
+ ConnectedLinePtr destSpecificConnectedLine = connectedLine;
+
+ BridgePartyIdHooksPtr partyIdHooks = mBridge->getPartyIdHooks();
+
+ // Allow the ForwardingConnectedLinePartyId hooks to alter the ConnectedLine record.
+ for(vector<ForwardingConnectedLinePartyIdHookPrx>::const_iterator i = partyIdHooks->getForwardingConnectedLinePartyIdHooks().begin();
+ i != partyIdHooks->getForwardingConnectedLinePartyIdHooks().end(); ++i)
+ {
+ AsteriskSCF::System::Hook::V1::HookResult hookResult = (*i)->modifyForwardingConnectedLine(mSourceSession->getSession(),
+ destinationSession->getSession(),
+ currentConnectedLine, destSpecificConnectedLine);
+
+ if (hookResult.status == AsteriskSCF::System::Hook::V1::Succeeded)
+ {
+ currentConnectedLine = destSpecificConnectedLine;
+ }
+ }
+
+ // Forward the info via the SessionController for this session.
+ destinationSession->getSessionController()->updateConnectedLine(currentConnectedLine);
+ }
+ catch (const std::exception e)
+ {
+ mLogger(Debug) << FUNLOG << " : " << e.what();
+ }
+ }
+
+private:
+ BridgeImplPtr mBridge;
+ SessionWrapperPtr mSourceSession;
+ Logger mLogger;
+};
+
+/**
+ * Applies the ReceiveConnectedLine hooks to the new ConnectedLine
+ * information before caching it for the specified session.
+ */
+class UpdateConnectedLineTask : public QueuedTask
+{
+public:
+ UpdateConnectedLineTask(const BridgeImplPtr& bridge,
+ const SessionWrapperPtr& sourceSession,
+ const ConnectedLinePtr& connectedLine,
+ const Logger& logger) :
+ QueuedTask("UpdateConnectedLineTask"),
+ mBridge(bridge),
+ mSourceSession(sourceSession),
+ mConnectedLine(connectedLine),
+ mLogger(logger)
+ {
+ }
+
+protected:
+ bool executeImpl()
+ {
+ try
+ {
+ mLogger(Debug) << FUNLOG;
+
+ ConnectedLinePtr currentConnectedLine = mConnectedLine;
+ ConnectedLinePtr updatedConnectedLine = mConnectedLine;
+
+ BridgePartyIdHooksPtr partyIdHooks = mBridge->getPartyIdHooks();
+
+ // Allow the ReceivedConnectedLinePartyId hooks to alter the ConnectedLine record.
+ for(vector<ReceivedConnectedLinePartyIdHookPrx>::const_iterator i = partyIdHooks->getReceivedConnectedLinePartyIdHooks().begin();
+ i != partyIdHooks->getReceivedConnectedLinePartyIdHooks().end(); ++i)
+ {
+ AsteriskSCF::System::Hook::V1::HookResult hookResult = (*i)->modifyReceivedConnectedLine(mSourceSession->getSession(),
+ currentConnectedLine, updatedConnectedLine);
+
+ if (hookResult.status == AsteriskSCF::System::Hook::V1::Succeeded)
+ {
+ currentConnectedLine = updatedConnectedLine;
+ }
+ }
+
+ // Cache this value.
+ mSourceSession->setConnectedLine(currentConnectedLine);
+ }
+ catch (const std::exception e)
+ {
+ mLogger(Debug) << FUNLOG << " : " << e.what();
+ }
+
+ return true;
+ }
+
+private:
+ BridgeImplPtr mBridge;
+ SessionWrapperPtr mSourceSession;
+ ConnectedLinePtr mConnectedLine;
+ Logger mLogger;
+};
+
class RemoveSessionsNotify : public QueuedTask
{
public:
@@ -410,14 +688,14 @@ public:
cb->ice_response();
}
- void updateConnectedLine(const ConnectedLinePtr&, const Ice::Current&)
+ void updateConnectedLine(const ConnectedLinePtr& connectedLine, const Ice::Current&)
{
- // TBD
+ mBridge->updateConnectedLine(mSelf, connectedLine);
}
- void updateRedirecting(const RedirectingPtr&, const ::Ice::Current&)
+ void redirectingUpdated(const RedirectingPtr& redirecting, const ::Ice::Current&)
{
- // TBD
+ mBridge->redirectingUpdated(mSelf, redirecting);
}
private:
@@ -697,6 +975,7 @@ private:
BridgeImpl::BridgeImpl(const string& name, const Ice::ObjectAdapterPtr& adapter,
const vector<BridgeListenerPrx>& listeners,
const BridgeListenerMgrPtr& listenerMgr,
+ const BridgePartyIdHooksPtr& partyIdHooks,
const ReplicatorSmartPrx& replicator,
const BridgeStateItemPtr& state,
const Logger& logger) :
@@ -706,6 +985,7 @@ BridgeImpl::BridgeImpl(const string& name, const Ice::ObjectAdapterPtr& adapter,
mName(name),
mObjAdapter(adapter),
mListeners(listenerMgr),
+ mPartyIdHooks(partyIdHooks),
mReplicator(replicator),
mSessionListener(createSessionListener(mSessions, logger)),
mLogger(logger)
@@ -727,6 +1007,55 @@ BridgeImpl::~BridgeImpl()
//
}
+/**
+ * Process an updated ConnectedLine record from a session.
+ */
+void BridgeImpl::updateConnectedLine(const SessionWrapperPtr& sourceSession, const ConnectedLinePtr& connectedLine)
+{
+ try
+ {
+ QueuedTasks tasks;
+
+ // Updates the cached ConnectedLine party id information for the given session.
+ // - Applies receive hooks on the received ConnectedLine info before caching.
+ tasks.push_back(new UpdateConnectedLineTask(this, sourceSession, connectedLine, mLogger));
+
+
+ // Forwards the ConnectedLine information to the other sessions in the bridge.
+ // - Applies forwarding hooks to the cached ConnectedLine info before forwarding.
+ tasks.push_back(new ForwardConnectedLineTask(this, sourceSession, mLogger));
+
+ ExecutorPtr runner(new Executor(tasks, mLogger));
+ runner->start();
+ }
+ catch (const std::exception e)
+ {
+ mLogger(Debug) << FUNLOG << " : " << e.what();
+ }
+}
+
+/**
+ * Process an updated Redirecting record from a session.
+ */
+void BridgeImpl::redirectingUpdated(const SessionWrapperPtr& sourceSession, const RedirectingPtr& redirecting)
+{
+ try
+ {
+ QueuedTasks tasks;
+
+
+ // Forwards the Redirecting information to the other sessions in the bridge.
+ // - Applies forwarding hooks to the Redirecrting info before forwarding.
+ tasks.push_back(new ForwardRedirectingUpdatedTask(this, sourceSession, redirecting, mLogger));
+ ExecutorPtr runner(new Executor(tasks, mLogger));
+ runner->start();
+ }
+ catch (const std::exception e)
+ {
+ mLogger(Debug) << FUNLOG << " : " << e.what();
+ }
+}
+
void BridgeImpl::addSessions_async(const AMD_Bridge_addSessionsPtr& callback, const SessionSeq& sessions,
const Ice::Current&)
{
@@ -1300,6 +1629,7 @@ IceUtil::Handle<AsteriskSCF::BridgeService::BridgeServant>
AsteriskSCF::BridgeService::BridgeServant::create(const string& name, const Ice::ObjectAdapterPtr& objectAdapter,
const vector<BridgeListenerPrx>& listeners,
const AsteriskSCF::BridgeService::BridgeListenerMgrPtr& listenerMgr,
+ const BridgePartyIdHooksPtr& partyIdHooks,
const ReplicatorSmartPrx& replicator,
const Logger& logger)
{
@@ -1312,12 +1642,13 @@ AsteriskSCF::BridgeService::BridgeServant::create(const string& name, const Ice:
// allowing localized resources to be used.
//
state->mediaReplicationPolicy = Replicate;
- return new BridgeImpl(name, objectAdapter, listeners, listenerMgr, replicator, state, logger);
+ return new BridgeImpl(name, objectAdapter, listeners, listenerMgr, partyIdHooks, replicator, state, logger);
}
IceUtil::Handle<AsteriskSCF::BridgeService::BridgeServant>
AsteriskSCF::BridgeService::BridgeServant::create(const Ice::ObjectAdapterPtr& objectAdapter,
const AsteriskSCF::BridgeService::BridgeListenerMgrPtr& listenerMgr,
+ const BridgePartyIdHooksPtr& partyIdHooks,
const ReplicatorSmartPrx& replicator,
const Logger& logger,
const AsteriskSCF::Replication::BridgeService::V1::BridgeStateItemPtr& state)
@@ -1325,7 +1656,7 @@ AsteriskSCF::BridgeService::BridgeServant::create(const Ice::ObjectAdapterPtr& o
logger(Debug) << FUNLOG << ": creating replica for " << state->bridgeId;
IceUtil::Handle<AsteriskSCF::BridgeService::BridgeServant> bridge(
new BridgeImpl(state->bridgeId, objectAdapter, vector<BridgeListenerPrx>(),
- listenerMgr, replicator, state, logger));
+ listenerMgr, partyIdHooks, replicator, state, logger));
return bridge;
}
diff --git a/src/BridgeImpl.h b/src/BridgeImpl.h
index 2c9ab9f..7f29bb9 100644
--- a/src/BridgeImpl.h
+++ b/src/BridgeImpl.h
@@ -18,6 +18,7 @@
#include <AsteriskSCF/SessionCommunications/SessionCommunicationsIf.h>
#include <boost/thread/shared_mutex.hpp>
#include <vector>
+#include "BridgePartyIdExtensionPoint.h"
#include "BridgeReplicatorIf.h"
#include "BridgeListenerMgr.h"
#include "BridgeServiceConfig.h"
@@ -136,6 +137,7 @@ public:
const Ice::ObjectAdapterPtr& objectAdapter,
const std::vector<AsteriskSCF::SessionCommunications::V1::BridgeListenerPrx>& listeners,
const AsteriskSCF::BridgeService::BridgeListenerMgrPtr& listenerMgr,
+ const AsteriskSCF::BridgeService::BridgePartyIdHooksPtr& partyIdHooks,
const ReplicatorSmartPrx& replicator,
const AsteriskSCF::System::Logging::Logger& logger);
@@ -146,6 +148,7 @@ public:
**/
static IceUtil::Handle<BridgeServant> create(const Ice::ObjectAdapterPtr& objectAdapter,
const AsteriskSCF::BridgeService::BridgeListenerMgrPtr& listenerMgr,
+ const AsteriskSCF::BridgeService::BridgePartyIdHooksPtr& partyIdHooks,
const ReplicatorSmartPrx& replicator,
const AsteriskSCF::System::Logging::Logger& logger,
const AsteriskSCF::Replication::BridgeService::V1::BridgeStateItemPtr& state);
diff --git a/src/BridgeManagerImpl.cpp b/src/BridgeManagerImpl.cpp
index 7361dc5..b596b99 100644
--- a/src/BridgeManagerImpl.cpp
+++ b/src/BridgeManagerImpl.cpp
@@ -44,7 +44,9 @@ class BridgeManagerImpl : public BridgeManagerServant
{
public:
- BridgeManagerImpl(const Ice::ObjectAdapterPtr& adapter, const string& name,
+ BridgeManagerImpl(const Ice::ObjectAdapterPtr& adapter,
+ const string& name,
+ const BridgePartyIdExtensionPointPtr& partyIdExtensionPoint,
const BridgeReplicationContextPtr& replicationContext, const Logging::Logger& logger);
~BridgeManagerImpl();
@@ -92,6 +94,7 @@ private:
boost::shared_mutex mLock;
string mName;
+ BridgePartyIdExtensionPointPtr mPartyIdExtensionPoint;
vector<BridgeInfo> mBridges;
Ice::ObjectAdapterPtr mAdapter;
BridgeReplicationContextPtr mReplicationContext;
@@ -109,13 +112,17 @@ private:
typedef IceUtil::Handle<BridgeManagerImpl> BridgeManagerImplPtr;
-BridgeManagerImpl::BridgeManagerImpl(const Ice::ObjectAdapterPtr& adapter, const string& name, const BridgeReplicationContextPtr& replicationContext,
- const Logger& logger) :
- mName(name),
- mAdapter(adapter),
- mReplicationContext(replicationContext),
- mLogger(logger),
- mState(new BridgeManagerStateItem)
+BridgeManagerImpl::BridgeManagerImpl(const Ice::ObjectAdapterPtr& adapter,
+ const string& name,
+ const BridgePartyIdExtensionPointPtr& partyIdExtensionPoint,
+ const BridgeReplicationContextPtr& replicationContext,
+ const Logger& logger) :
+ mName(name),
+ mPartyIdExtensionPoint(partyIdExtensionPoint),
+ mAdapter(adapter),
+ mReplicationContext(replicationContext),
+ mLogger(logger),
+ mState(new BridgeManagerStateItem)
{
mLogger(Info) << "Created AsteriskSCF Session-Oriented Bridge Manager." ;
mListeners = new BridgeManagerListenerMgr(mAdapter->getCommunicator(), mName, mSourceProxy);
@@ -189,7 +196,8 @@ void BridgeManagerImpl::createBridge_async(const AMD_BridgeManager_createBridgeP
listeners.push_back(listener);
}
- BridgeServantPtr bridge = BridgeServant::create(stringId, mAdapter, listeners, mgr, mReplicationContext->getReplicator(), mLogger);
+ BridgeServantPtr bridge = BridgeServant::create(stringId, mAdapter, listeners, mgr,
+ mPartyIdExtensionPoint->getHooks(), mReplicationContext->getReplicator(), mLogger);
Ice::ObjectPrx obj = mAdapter->add(bridge, id);
mLogger(Info) << objectIdFromCurrent(current) << ": creating new bridge " << obj->ice_toString() << "." ;
@@ -388,7 +396,8 @@ void BridgeManagerImpl::createBridgeReplica(const BridgeStateItemPtr& state)
BridgePrx prx(BridgePrx::uncheckedCast(mAdapter->createProxy(id)));
BridgeListenerMgrPtr mgr(new BridgeListenerMgr(mAdapter->getCommunicator(), state->bridgeId, prx));
- BridgeServantPtr bridge = BridgeServant::create(mAdapter, mgr, mReplicationContext->getReplicator(), mLogger, state);
+ BridgeServantPtr bridge = BridgeServant::create(mAdapter, mgr,
+ mPartyIdExtensionPoint->getHooks(), mReplicationContext->getReplicator(), mLogger, state);
Ice::ObjectPrx obj = mAdapter->add(bridge, id);
mLogger(Info) << ": creating bridge replica " << obj->ice_toString() << "." ;
@@ -471,9 +480,11 @@ void BridgeManagerImpl::update()
} // End of anonymous namespace
BridgeManagerServantPtr
-AsteriskSCF::BridgeService::createBridgeManager(const Ice::ObjectAdapterPtr& adapter, const string& name,
- const BridgeReplicationContextPtr& replicationContext,
- const Logger& logger)
+AsteriskSCF::BridgeService::createBridgeManager(const Ice::ObjectAdapterPtr& adapter,
+ const string& name,
+ const BridgePartyIdExtensionPointPtr& partyIdExtensionPoint,
+ const BridgeReplicationContextPtr& replicationContext,
+ const Logger& logger)
{
- return new BridgeManagerImpl(adapter, name, replicationContext, logger);
+ return new BridgeManagerImpl(adapter, name, partyIdExtensionPoint, replicationContext, logger);
}
diff --git a/src/BridgeManagerImpl.h b/src/BridgeManagerImpl.h
index 62090a2..e1998dd 100644
--- a/src/BridgeManagerImpl.h
+++ b/src/BridgeManagerImpl.h
@@ -66,6 +66,10 @@ typedef IceUtil::Handle<BridgeManagerServant> BridgeManagerServantPtr;
*
* @param adapter The Ice object adapter for the BridgeManager all of the servants it will create.
*
+ *
+ * @param partyIdExtensionPoint Object that manages the hooks that have been added to this component for
+ * modifying Party Id information.
+ *
* @param name A name for this servant. This will be used to construct the new BridgeManager object's Ice::Identity.
* It is used to construct relative object ids for all objects that the bridge manager creates.
*
@@ -73,7 +77,9 @@ typedef IceUtil::Handle<BridgeManagerServant> BridgeManagerServantPtr;
*
**/
BridgeManagerServantPtr createBridgeManager(const Ice::ObjectAdapterPtr& adapter,
- const std::string& name, const BridgeReplicationContextPtr& replicationContext,
+ const std::string& name,
+ const BridgePartyIdExtensionPointPtr& partyIdExtensionPoint,
+ const BridgeReplicationContextPtr& replicationContext,
const AsteriskSCF::System::Logging::Logger& logger);
};
diff --git a/src/BridgePartyIdExtensionPoint.cpp b/src/BridgePartyIdExtensionPoint.cpp
new file mode 100644
index 0000000..2d168b2
--- /dev/null
+++ b/src/BridgePartyIdExtensionPoint.cpp
@@ -0,0 +1,189 @@
+/*
+ * Asterisk SCF -- An open-source communications framework.
+ *
+ * Copyright (C) 2011, Digium, Inc.
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk SCF project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE.txt file
+ * at the top of the source tree.
+ */
+
+#include <boost/thread/shared_mutex.hpp>
+
+#include <AsteriskSCF/logger.h>
+#include <AsteriskSCF/Collections/ProxySet.h>
+#include <AsteriskSCF/SessionCommunications/SessionCommunicationsExtensionPointsIf.h>
+
+#include "BridgePartyIdExtensionPoint.h"
+
+using namespace AsteriskSCF::System::Logging;
+using namespace AsteriskSCF::SessionCommunications::V1;
+using namespace AsteriskSCF::SessionCommunications::ExtensionPoints::V1;
+using namespace AsteriskSCF::BridgeService;
+
+namespace
+{
+
+class BridgePartyIdHooksImpl : public BridgePartyIdHooks
+{
+public:
+ BridgePartyIdHooksImpl(const std::vector<ReceivedConnectedLinePartyIdHookPrx>& receiveConnectedLineHooks,
+ const std::vector<ForwardingConnectedLinePartyIdHookPrx>& forwardingConnectedLineHooks,
+ const std::vector<ForwardingRedirectingPartyIdHookPrx>& forwardingRedirectingHooks);
+
+ const std::vector<ReceivedConnectedLinePartyIdHookPrx>& getReceivedConnectedLinePartyIdHooks();
+ const std::vector<ForwardingConnectedLinePartyIdHookPrx>& getForwardingConnectedLinePartyIdHooks();
+ const std::vector<ForwardingRedirectingPartyIdHookPrx>& getForwardingRedirectingPartyIdHooks();
+
+private:
+ std::vector<ReceivedConnectedLinePartyIdHookPrx> mReceiveConnectedLineHooks;
+ std::vector<ForwardingConnectedLinePartyIdHookPrx> mForwardingConnectedLineHooks;
+ std::vector<ForwardingRedirectingPartyIdHookPrx> mForwardingRedirectingHooks;
+};
+
+BridgePartyIdHooksImpl::BridgePartyIdHooksImpl(const std::vector<ReceivedConnectedLinePartyIdHookPrx>& receiveConnectedLineHooks,
+ const std::vector<ForwardingConnectedLinePartyIdHookPrx>& forwardingConnectedLineHooks,
+ const std::vector<ForwardingRedirectingPartyIdHookPrx>& forwardingRedirectingHooks)
+ : mReceiveConnectedLineHooks(receiveConnectedLineHooks),
+ mForwardingConnectedLineHooks(forwardingConnectedLineHooks),
+ mForwardingRedirectingHooks(forwardingRedirectingHooks)
+{
+}
+
+const std::vector<ReceivedConnectedLinePartyIdHookPrx>&
+ BridgePartyIdHooksImpl::getReceivedConnectedLinePartyIdHooks()
+{
+ return mReceiveConnectedLineHooks;
+}
+
+const std::vector<ForwardingConnectedLinePartyIdHookPrx>&
+ BridgePartyIdHooksImpl::getForwardingConnectedLinePartyIdHooks()
+{
+ return mForwardingConnectedLineHooks;
+}
+
+const std::vector<ForwardingRedirectingPartyIdHookPrx>&
+ BridgePartyIdHooksImpl::getForwardingRedirectingPartyIdHooks()
+{
+ return mForwardingRedirectingHooks;
+}
+
+class BridgePartyIdExtensionPointImpl :
+ public AsteriskSCF::BridgeService::BridgePartyIdExtensionPoint
+{
+public:
+ BridgePartyIdExtensionPointImpl(const Ice::ObjectAdapterPtr& adapter,
+ const AsteriskSCF::System::Logging::Logger& logger);
+
+ // PartyIdentificationExtensionPoint API implementation
+ void addReceivedConnectedLinePartyIdHook(
+ const ::AsteriskSCF::SessionCommunications::ExtensionPoints::V1::ReceivedConnectedLinePartyIdHookPrx& hook,
+ const Ice::Current& current);
+ void addForwardingConnectedLinePartyIdHook(
+ const ::AsteriskSCF::SessionCommunications::ExtensionPoints::V1::ForwardingConnectedLinePartyIdHookPrx& hook,
+ const Ice::Current& current);
+ void addForwardingRedirectingPartyIdHook(
+ const AsteriskSCF::SessionCommunications::ExtensionPoints::V1::ForwardingRedirectingPartyIdHookPrx& hook,
+ const Ice::Current& current);
+
+ void removeReceivedConnectedLinePartyIdHook(
+ const ::AsteriskSCF::SessionCommunications::ExtensionPoints::V1::ReceivedConnectedLinePartyIdHookPrx& hook,
+ const Ice::Current& current);
+ void removeForwardingConnectedLinePartyIdHook(
+ const ::AsteriskSCF::SessionCommunications::ExtensionPoints::V1::ForwardingConnectedLinePartyIdHookPrx& hook,
+ const Ice::Current& current);
+ void removeForwardingRedirectingPartyIdHook(
+ const AsteriskSCF::SessionCommunications::ExtensionPoints::V1::ForwardingRedirectingPartyIdHookPrx& hook,
+ const Ice::Current& current);
+
+ void clearPartyIdentificationHooks(const Ice::Current& current);
+
+ virtual BridgePartyIdHooksPtr getHooks();
+
+private:
+ AsteriskSCF::Collections::ProxySet<ReceivedConnectedLinePartyIdHookPrx>::SetPtr mReceiveConnectedLineHooks;
+ AsteriskSCF::Collections::ProxySet<ForwardingConnectedLinePartyIdHookPrx>::SetPtr mForwardingConnectedLineHooks;
+ AsteriskSCF::Collections::ProxySet<ForwardingRedirectingPartyIdHookPrx>::SetPtr mForwardingRedirectingHooks;
+
+ Logger mLogger;
+};
+
+} // end anon namespace
+
+BridgePartyIdExtensionPointImpl::BridgePartyIdExtensionPointImpl(
+ const Ice::ObjectAdapterPtr& adapter,
+ const AsteriskSCF::System::Logging::Logger& logger)
+ : mLogger(logger)
+
+{
+}
+
+// PartyIdentificationExtensionPoint API implementation
+void BridgePartyIdExtensionPointImpl::addReceivedConnectedLinePartyIdHook(
+ const ::AsteriskSCF::SessionCommunications::ExtensionPoints::V1::ReceivedConnectedLinePartyIdHookPrx& hook,
+ const Ice::Current& current)
+{
+ mReceiveConnectedLineHooks->add(hook);
+}
+
+void BridgePartyIdExtensionPointImpl::addForwardingConnectedLinePartyIdHook(
+ const ::AsteriskSCF::SessionCommunications::ExtensionPoints::V1::ForwardingConnectedLinePartyIdHookPrx& hook,
+ const Ice::Current& current)
+{
+ mForwardingConnectedLineHooks->add(hook);
+}
+
+void BridgePartyIdExtensionPointImpl::addForwardingRedirectingPartyIdHook(
+ const ::AsteriskSCF::SessionCommunications::ExtensionPoints::V1::ForwardingRedirectingPartyIdHookPrx& hook,
+ const Ice::Current& current)
+{
+ mForwardingRedirectingHooks->add(hook);
+}
+
+void BridgePartyIdExtensionPointImpl::removeReceivedConnectedLinePartyIdHook(
+ const ::AsteriskSCF::SessionCommunications::ExtensionPoints::V1::ReceivedConnectedLinePartyIdHookPrx& hook,
+ const Ice::Current& current)
+{
+ mReceiveConnectedLineHooks->remove(hook);
+}
+
+void BridgePartyIdExtensionPointImpl::removeForwardingConnectedLinePartyIdHook(
+ const ::AsteriskSCF::SessionCommunications::ExtensionPoints::V1::ForwardingConnectedLinePartyIdHookPrx& hook,
+ const Ice::Current& current)
+{
+ mForwardingConnectedLineHooks->remove(hook);
+}
+
+void BridgePartyIdExtensionPointImpl::removeForwardingRedirectingPartyIdHook(
+ const ::AsteriskSCF::SessionCommunications::ExtensionPoints::V1::ForwardingRedirectingPartyIdHookPrx& hook,
+ const Ice::Current& current)
+{
+ mForwardingRedirectingHooks->remove(hook);
+}
+
+void BridgePartyIdExtensionPointImpl::clearPartyIdentificationHooks(const Ice::Current& current)
+{
+ mReceiveConnectedLineHooks->clear();
+ mForwardingConnectedLineHooks->clear();
+ mForwardingRedirectingHooks->clear();
+}
+
+BridgePartyIdHooksPtr BridgePartyIdExtensionPointImpl::getHooks()
+{
+ return new BridgePartyIdHooksImpl(mReceiveConnectedLineHooks->getAll(),
+ mForwardingConnectedLineHooks->getAll(),
+ mForwardingRedirectingHooks->getAll());
+}
+
+AsteriskSCF::BridgeService::BridgePartyIdExtensionPointPtr
+ AsteriskSCF::BridgeService::createPartyIdExtensionPoint(const Ice::ObjectAdapterPtr& adapter,
+ const AsteriskSCF::System::Logging::Logger& logger)
+{
+ return new BridgePartyIdExtensionPointImpl(adapter, logger);
+}
diff --git a/src/BridgePartyIdExtensionPoint.h b/src/BridgePartyIdExtensionPoint.h
new file mode 100644
index 0000000..376e0a8
--- /dev/null
+++ b/src/BridgePartyIdExtensionPoint.h
@@ -0,0 +1,111 @@
+/*
+ * Asterisk SCF -- An open-source communications framework.
+ *
+ * Copyright (C) 2010-2011, Digium, Inc.
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk SCF project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE.txt file
+ * at the top of the source tree.
+ */
+#pragma once
+
+#include <AsteriskSCF/SessionCommunications/SessionCommunicationsExtensionPointsIf.h>
+#include <AsteriskSCF/logger.h>
+
+namespace AsteriskSCF
+{
+namespace BridgeService
+{
+
+/**
+ * This class is used to hold a snapshot of the party id hooks
+ * at the time of bridge creation. The hook proxies are internally thread safe.
+ * We provide each bridge its own copy of the hooks to alleviate
+ * contention for a lock that would be required if each bridge was
+ * trying to fetch the hooks directly from the BridgePartyIdExtensionPoint (which
+ * has the primary cache of party id hooks).
+ */
+class BridgePartyIdHooks : public IceUtil::Shared
+{
+public:
+ virtual ~BridgePartyIdHooks() {}
+
+ /**
+ * Get the received ConnectedLine party id hooks.
+ */
+ virtual const std::vector<AsteriskSCF::SessionCommunications::ExtensionPoints::V1::ReceivedConnectedLinePartyIdHookPrx>&
+ getReceivedConnectedLinePartyIdHooks() = 0;
+
+ /**
+ * Get the forwarding ConnectedLine Party Id hooks.
+ */
+ virtual const std::vector<AsteriskSCF::SessionCommunications::ExtensionPoints::V1::ForwardingConnectedLinePartyIdHookPrx>&
+ getForwardingConnectedLinePartyIdHooks() = 0;
+
+ /**
+ * Get the forwarding Redirecting Party Id hooks.
+ */
+ virtual const std::vector<AsteriskSCF::SessionCommunications::ExtensionPoints::V1::ForwardingRedirectingPartyIdHookPrx>&
+ getForwardingRedirectingPartyIdHooks() = 0;
+};
+
+typedef IceUtil::Handle<BridgePartyIdHooks> BridgePartyIdHooksPtr;
+
+/**
+ * This is our servant for the PartyIdentificationExtensionPoint. It caches the
+ * hooks that are added.
+ */
+class BridgePartyIdExtensionPoint :
+ public AsteriskSCF::SessionCommunications::ExtensionPoints::V1::PartyIdentificationExtensionPoint
+{
+public:
+ virtual ~BridgePartyIdExtensionPoint() {}
+
+ // PartyIdentificationExtensionPoint API implementation
+
+ virtual void addReceivedConnectedLinePartyIdHook(
+ const AsteriskSCF::SessionCommunications::ExtensionPoints::V1::ReceivedConnectedLinePartyIdHookPrx& hook,
+ const Ice::Current& current) = 0;
+ virtual void addForwardingConnectedLinePartyIdHook(
+ const AsteriskSCF::SessionCommunications::ExtensionPoints::V1::ForwardingConnectedLinePartyIdHookPrx& hook,
+ const Ice::Current& current) = 0;
+ virtual void addForwardingRedirectingPartyIdHook(
+ const AsteriskSCF::SessionCommunications::ExtensionPoints::V1::ForwardingRedirectingPartyIdHookPrx& hook,
+ const Ice::Current& current) = 0;
+
+ virtual void removeReceivedConnectedLinePartyIdHook(
+ const AsteriskSCF::SessionCommunications::ExtensionPoints::V1::ReceivedConnectedLinePartyIdHookPrx& hook,
+ const Ice::Current& current) = 0;
+ virtual void removeForwardingConnectedLinePartyIdHook(
+ const AsteriskSCF::SessionCommunications::ExtensionPoints::V1::ForwardingConnectedLinePartyIdHookPrx& hook,
+ const Ice::Current& current) = 0;
+ virtual void removeForwardingRedirectingPartyIdHook(
+ const AsteriskSCF::SessionCommunications::ExtensionPoints::V1::ForwardingRedirectingPartyIdHookPrx& hook,
+ const Ice::Current& current) = 0;
+
+ virtual void clearPartyIdentificationHooks(const Ice::Current& current) = 0;
+
+ // Implementation
+
+ /**
+ * This method provides a BridgePartyIdHooks object
+ * which contains a copy of the hooks as they exist
+ * at the time this operation is called.
+ */
+ virtual BridgePartyIdHooksPtr getHooks() = 0;
+};
+
+typedef IceUtil::Handle<BridgePartyIdExtensionPoint> BridgePartyIdExtensionPointPtr;
+
+
+BridgePartyIdExtensionPointPtr createPartyIdExtensionPoint(const Ice::ObjectAdapterPtr& adapter,
+ const AsteriskSCF::System::Logging::Logger& logger);
+
+} // End of namespace Bridging.
+} // End of namespace AsteriskSCF.
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index c7fbc72..82839c2 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -22,6 +22,8 @@ astscf_component_add_files(bridgeservice SessionCollection.cpp)
astscf_component_add_files(bridgeservice SessionCollection.h)
astscf_component_add_files(bridgeservice SessionOperations.cpp)
astscf_component_add_files(bridgeservice SessionOperations.h)
+astscf_component_add_files(bridgeservice BridgePartyIdExtensionPoint.cpp)
+astscf_component_add_files(bridgeservice BridgePartyIdExtensionPoint.h)
astscf_component_add_files(bridgeservice ServiceUtil.h)
astscf_component_add_files(bridgeservice DebugUtil.h)
astscf_component_add_files(bridgeservice MediaSplicer.h)
diff --git a/src/Component.cpp b/src/Component.cpp
index 03b6484..6e42dae 100644
--- a/src/Component.cpp
+++ b/src/Component.cpp
@@ -29,9 +29,11 @@
#include "BridgeManagerImpl.h"
#include "BridgeReplicatorStateListenerI.h"
#include "BridgeReplicationContext.h"
+#include "BridgePartyIdExtensionPoint.h"
using namespace AsteriskSCF::System::Logging;
using namespace AsteriskSCF::SessionCommunications::V1;
+using namespace AsteriskSCF::SessionCommunications::ExtensionPoints::V1;
using namespace AsteriskSCF::Core::Discovery::V1;
using namespace AsteriskSCF::System::Component::V1;
using namespace AsteriskSCF::BridgeService;
@@ -75,10 +77,13 @@ private:
// Other base Component overrides
virtual ReplicationContextPtr createReplicationContext(ReplicationStateType state);
+ BridgePartyIdExtensionPointPtr mPartyIdExtensionPoint;
+ PartyIdentificationExtensionPointPrx mPartyIdExtensionPointPrx;
ReplicatorSmartPrx mReplicator;
BridgeManagerServantPtr mBridgeManager;
BridgeManagerPrx mBridgeManagerPrx;
LocatorRegistrationWrapperPtr mBridgeManagerRegistration;
+ LocatorRegistrationWrapperPtr mPartyIdExtensionRegistration;
RegisterThreadPtr mRegisterThread;
ReplicatorListenerPrx mReplicatorListenerPrx;
bool mListeningToReplicator;
@@ -120,13 +125,19 @@ void Component::createPrimaryServices()
{
std::string managerName =
getCommunicator()->getProperties()->getPropertyWithDefault(getName() + ".ManagerId", "BridgeManager");
-
//
// It's very important that uncheckedCast's be used here as there are no guarantees
// that the object adapter is activated yet. If it is not, then this can hang.
//
+
+ std::string extensionPointName =
+ getCommunicator()->getProperties()->getPropertyWithDefault(getName() + ".PartyIdentExtensionPoint", "BridgePartyIdExtensionPoint");
+ mPartyIdExtensionPoint = createPartyIdExtensionPoint(getServiceAdapter(), lg);
+ mPartyIdExtensionPointPrx = PartyIdentificationExtensionPointPrx::uncheckedCast(getServiceAdapter()->add(mPartyIdExtensionPoint,
+ getCommunicator()->stringToIdentity(extensionPointName)));
+
BridgeReplicationContextPtr replicationContext = boost::static_pointer_cast<BridgeReplicationContext>(getReplicationContext());
- mBridgeManager = createBridgeManager(getServiceAdapter(), managerName, replicationContext, lg);
+ mBridgeManager = createBridgeManager(getServiceAdapter(), managerName, mPartyIdExtensionPoint, replicationContext, lg);
mBridgeManagerPrx = BridgeManagerPrx::uncheckedCast(getServiceAdapter()->add(mBridgeManager,
getCommunicator()->stringToIdentity(managerName)));
assert(mBridgeManagerPrx != 0);
@@ -134,6 +145,7 @@ void Component::createPrimaryServices()
{
throw IceBox::FailureException(__FILE__, __LINE__, "Unable to instantiate bridge manager object");
}
+
}
/**
@@ -146,6 +158,11 @@ void Component::preparePrimaryServicesForDiscovery()
mBridgeManagerRegistration = this->wrapServiceForRegistration(mBridgeManagerPrx,
BridgeManagerDiscoveryCategory);
managePrimaryService(mBridgeManagerRegistration);
+
+ mPartyIdExtensionRegistration = this->wrapServiceForRegistration(mPartyIdExtensionPointPrx,
+ PartyIdentificationHookLocatorCategory);
+ managePrimaryService(mPartyIdExtensionRegistration);
+
}
catch (const Ice::Exception& e)
{
diff --git a/src/SessionWrapper.cpp b/src/SessionWrapper.cpp
index 1178f5e..b625441 100644
--- a/src/SessionWrapper.cpp
+++ b/src/SessionWrapper.cpp
@@ -22,6 +22,7 @@
using namespace AsteriskSCF::System::Logging;
using namespace AsteriskSCF::SessionCommunications::V1;
+using namespace AsteriskSCF::SessionCommunications::PartyIdentification::V1;
using namespace AsteriskSCF::BridgeService;
using namespace AsteriskSCF::Replication::BridgeService::V1;
using namespace AsteriskSCF;
@@ -391,7 +392,8 @@ SessionWrapper::SessionWrapper(const BridgedSessionPtr& session,
mLogger(logger),
mId(mSession->key),
mSplicer(splicer),
- mActivities(new Executor(mLogger))
+ mActivities(new Executor(mLogger)),
+ mConnectedLineSet(false)
{
}
@@ -614,6 +616,32 @@ void SessionWrapper::shutdown(const SessionListenerPrx& listener, const Response
// shutdownRunner->start();
}
+/**
+ * Set the connected line information associcated with this session.
+ */
+void SessionWrapper::setConnectedLine(const ConnectedLinePtr& connectedLine)
+{
+ boost::unique_lock<boost::shared_mutex> lock(mLock);
+ mConnectedLine = connectedLine;
+ mConnectedLineSet = true;
+}
+
+/**
+ * Get the connected line information that's been cached for this session.
+ */
+bool SessionWrapper::getConnectedLine(ConnectedLinePtr& connectedLine)
+{
+ boost::unique_lock<boost::shared_mutex> lock(mLock);
+ if (!mConnectedLineSet)
+ {
+ return false;
+ }
+
+ connectedLine = mConnectedLine;
+ return true;
+}
+
+
AsteriskSCF::Replication::BridgeService::V1::BridgedSessionState SessionWrapper::setState(const AsteriskSCF::Replication::BridgeService::V1::BridgedSessionState newState)
{
mLogger(Debug) << FUNLOG << ": updating state " << mId;
diff --git a/src/SessionWrapper.h b/src/SessionWrapper.h
index 0bdef83..6fc3f43 100644
--- a/src/SessionWrapper.h
+++ b/src/SessionWrapper.h
@@ -145,6 +145,19 @@ public:
* Disconnection helper.
**/
void unplugMedia();
+
+ /**
+ * Set the connected line information associcated with this session.
+ * This is information received from the session.
+ */
+ void setConnectedLine(const AsteriskSCF::SessionCommunications::PartyIdentification::V1::ConnectedLinePtr& connectedLine);
+
+ /**
+ * Gets a reference to the cached Connected Line party identification information if it's available.
+ * @param connectedLine A reference to set the cached Connected Line record (if available).
+ * @return true if the connectedLine parameter was set.
+ */
+ bool getConnectedLine(AsteriskSCF::SessionCommunications::PartyIdentification::V1::ConnectedLinePtr& connectedLine);
private:
@@ -157,6 +170,9 @@ private:
MediaSplicerPtr mSplicer;
ExecutorPtr mActivities;
AsteriskSCF::SessionCommunications::V1::SessionControllerPrx mSessionController;
+ AsteriskSCF::SessionCommunications::PartyIdentification::V1::ConnectedLinePtr mConnectedLine;
+ bool mConnectedLineSet;
+
/**
* Sends changes to the replication service. This should never occur
-----------------------------------------------------------------------
--
asterisk-scf/integration/bridging.git
More information about the asterisk-scf-commits
mailing list