summaryrefslogtreecommitdiff
path: root/cpp/src
diff options
context:
space:
mode:
Diffstat (limited to 'cpp/src')
-rw-r--r--cpp/src/Ice/LoggerAdminI.cpp586
-rw-r--r--cpp/src/Ice/PropertyNames.cpp4
-rw-r--r--cpp/src/Ice/PropertyNames.h8
3 files changed, 267 insertions, 331 deletions
diff --git a/cpp/src/Ice/LoggerAdminI.cpp b/cpp/src/Ice/LoggerAdminI.cpp
index 299f3718087..7d71c5556a3 100644
--- a/cpp/src/Ice/LoggerAdminI.cpp
+++ b/cpp/src/Ice/LoggerAdminI.cpp
@@ -8,45 +8,42 @@
// **********************************************************************
#include <Ice/LoggerAdminI.h>
+#include <Ice/Initialize.h>
+#include <Ice/Communicator.h>
#include <Ice/RemoteLogger.h>
#include <Ice/Properties.h>
#include <Ice/ObjectAdapter.h>
-#include <Ice/Communicator.h>
#include <Ice/Connection.h>
#include <Ice/LocalException.h>
#include <Ice/LoggerUtil.h>
#include <set>
+using namespace Ice;
using namespace std;
namespace
{
-class LoggerAdminI : public Ice::LoggerAdmin
+class LoggerAdminI : public LoggerAdmin
{
public:
- LoggerAdminI(const string&, const Ice::PropertiesPtr&);
-
- virtual void attachRemoteLogger(const Ice::RemoteLoggerPrx&, const Ice::LogMessageTypeSeq&,
- const Ice::StringSeq&, Ice::Int, const Ice::Current&);
+ LoggerAdminI(const string&, const PropertiesPtr&);
- virtual void detachRemoteLogger(const Ice::RemoteLoggerPrx&, const Ice::Current&);
+ virtual void attachRemoteLogger(const RemoteLoggerPrx&, const LogMessageTypeSeq&,
+ const StringSeq&, Int, const Current&);
- virtual Ice::LogMessageSeq getLog(const Ice::LogMessageTypeSeq&,
- const Ice::StringSeq&, Ice::Int, string&,
- const Ice::Current&);
+ virtual void detachRemoteLogger(const RemoteLoggerPrx&, const Current&);
- vector<Ice::RemoteLoggerPrx> log(const Ice::LogMessage&);
+ virtual LogMessageSeq getLog(const LogMessageTypeSeq&, const StringSeq&, Int, string&, const Current&);
- void deadRemoteLogger(const Ice::RemoteLoggerPrx&,
- const Ice::LoggerPtr&,
- const Ice::LocalException&, const string&);
-
- void run(const Ice::LoggerPtr&);
void destroy();
+ vector<RemoteLoggerPrx> log(const LogMessage&);
+
+ void deadRemoteLogger(const RemoteLoggerPrx&, const LoggerPtr&, const LocalException&, const string&);
+
const string& getFacetName() const
{
return _facetName;
@@ -57,29 +54,33 @@ public:
return _traceLevel;
}
+ const CallbackPtr& getRemoteCallCompleted() const
+ {
+ return _remoteCallCompleted;
+ }
+
private:
- bool removeRemoteLogger(const Ice::RemoteLoggerPrx&);
+ bool removeRemoteLogger(const RemoteLoggerPrx&);
- void remoteCallCompleted(const Ice::AsyncResultPtr&);
+ void remoteCallCompleted(const AsyncResultPtr&);
const string _facetName;
- IceUtil::Monitor<IceUtil::Mutex> _monitor;
- list<Ice::LogMessage> _queue;
+ IceUtil::Mutex _mutex;
+ list<LogMessage> _queue;
int _logCount; // non-trace messages
const int _maxLogCount;
int _traceCount;
const int _maxTraceCount;
const int _traceLevel;
- IceUtil::Time _pingPeriod;
- list<Ice::LogMessage>::iterator _oldestTrace;
- list<Ice::LogMessage>::iterator _oldestLog;
+ list<LogMessage>::iterator _oldestTrace;
+ list<LogMessage>::iterator _oldestLog;
struct ObjectIdentityCompare
{
- bool operator()(const Ice::RemoteLoggerPrx& lhs, const Ice::RemoteLoggerPrx& rhs)
+ bool operator()(const RemoteLoggerPrx& lhs, const RemoteLoggerPrx& rhs)
{
//
// Caller should make sure that proxies are never null
@@ -92,17 +93,17 @@ private:
struct Filters
{
- Filters(const Ice::LogMessageTypeSeq& m, const Ice::StringSeq& c) :
+ Filters(const LogMessageTypeSeq& m, const StringSeq& c) :
messageTypes(m.begin(), m.end()),
traceCategories(c.begin(), c.end())
{
}
- const set<Ice::LogMessageType> messageTypes;
+ const set<LogMessageType> messageTypes;
const set<string> traceCategories;
};
- typedef map<Ice::RemoteLoggerPrx, Filters, ObjectIdentityCompare> RemoteLoggerMap;
+ typedef map<RemoteLoggerPrx, Filters, ObjectIdentityCompare> RemoteLoggerMap;
struct GetRemoteLoggerMapKey
{
@@ -115,75 +116,63 @@ private:
RemoteLoggerMap _remoteLoggerMap;
- const Ice::CallbackPtr _remoteCallCompleted;
+ const CallbackPtr _remoteCallCompleted;
- bool _destroyed;
- bool _pingThreadStarted;
- IceUtil::ThreadControl _pingThreadControl;
+ CommunicatorPtr _sendLogCommunicator;
};
typedef IceUtil::Handle<LoggerAdminI> LoggerAdminIPtr;
-class PingThread : public IceUtil::Thread
-{
-public:
- PingThread(const LoggerAdminIPtr&, const Ice::LoggerPtr&);
-
- virtual void run();
-
-private:
-
- LoggerAdminIPtr _loggerAdmin;
- Ice::LoggerPtr _logger;
-};
-
-
class Job : public IceUtil::Shared
{
public:
- Job(const vector<Ice::RemoteLoggerPrx>& r, const Ice::LogMessage& l) :
+ Job(const vector<RemoteLoggerPrx>& r, const LogMessage& l) :
remoteLoggers(r),
logMessage(l)
{
}
- const vector<Ice::RemoteLoggerPrx> remoteLoggers;
- const Ice::LogMessage logMessage;
+ const vector<RemoteLoggerPrx> remoteLoggers;
+ const LogMessage logMessage;
};
typedef IceUtil::Handle<Job> JobPtr;
-class LoggerAdminLoggerI : public Ice::LoggerAdminLogger
+class LoggerAdminLoggerI : public LoggerAdminLogger
{
public:
- LoggerAdminLoggerI(const std::string&, const Ice::PropertiesPtr&, const Ice::LoggerPtr&);
+ LoggerAdminLoggerI(const std::string&, const PropertiesPtr&, const LoggerPtr&);
virtual void print(const std::string&);
virtual void trace(const std::string&, const std::string&);
virtual void warning(const std::string&);
virtual void error(const std::string&);
virtual std::string getPrefix();
- virtual Ice::LoggerPtr cloneWithPrefix(const std::string&);
+ virtual LoggerPtr cloneWithPrefix(const std::string&);
- virtual void addAdminFacet(const Ice::CommunicatorPtr&);
+ virtual void addAdminFacet(const CommunicatorPtr&);
virtual void destroy();
+ const LoggerPtr& getLocalLogger() const
+ {
+ return _localLogger;
+ }
+
void run();
private:
- void log(const Ice::LogMessage&);
+ void log(const LogMessage&);
- const Ice::LoggerPtr _localLogger;
+ const LoggerPtr _localLogger;
const LoggerAdminIPtr _loggerAdmin;
IceUtil::Monitor<IceUtil::Mutex> _monitor;
bool _destroyed;
- bool _sendLogThreadStarted;
- IceUtil::ThreadControl _sendLogThreadControl;
+ IceUtil::ThreadPtr _sendLogThread;
std::deque<JobPtr> _jobQueue;
};
typedef IceUtil::Handle<LoggerAdminLoggerI> LoggerAdminLoggerIPtr;
@@ -204,11 +193,15 @@ private:
//
+// Helper functions
+//
+
+//
// Filter out messages from in/out logMessages list
//
void
-filterLogMessages(Ice::LogMessageSeq& logMessages, const set<Ice::LogMessageType>& messageTypes,
- const set<string>& traceCategories, Ice::Int messageMax)
+filterLogMessages(LogMessageSeq& logMessages, const set<LogMessageType>& messageTypes,
+ const set<string>& traceCategories, Int messageMax)
{
if(messageMax == 0)
{
@@ -222,13 +215,13 @@ filterLogMessages(Ice::LogMessageSeq& logMessages, const set<Ice::LogMessageType
else if(!messageTypes.empty() || !traceCategories.empty() || messageMax > 0)
{
int count = 0;
- Ice::LogMessageSeq::reverse_iterator p = logMessages.rbegin();
+ LogMessageSeq::reverse_iterator p = logMessages.rbegin();
while(p != logMessages.rend())
{
bool keepIt = false;
if(messageTypes.empty() || messageTypes.count(p->type) != 0)
{
- if(p->type != Ice::TraceMessage || traceCategories.empty() ||
+ if(p->type != TraceMessage || traceCategories.empty() ||
traceCategories.count(p->traceCategory) != 0)
{
keepIt = true;
@@ -255,78 +248,134 @@ filterLogMessages(Ice::LogMessageSeq& logMessages, const set<Ice::LogMessageType
// p.base() points to p "+1"; the erase invalidates p so we
// need to rebuild it
//
- p = Ice::LogMessageSeq::reverse_iterator(logMessages.erase(p.base()));
+ p = LogMessageSeq::reverse_iterator(logMessages.erase(p.base()));
}
}
}
// else, don't need any filtering
}
+//
+// Change this proxy's communicator, while keeping its invocation timeout
+//
+RemoteLoggerPrx
+changeCommunicator(const RemoteLoggerPrx& prx, const CommunicatorPtr& communicator)
+{
+ if(prx == 0)
+ {
+ return 0;
+ }
+
+ RemoteLoggerPrx result = RemoteLoggerPrx::uncheckedCast(communicator->stringToProxy(prx->ice_toString()));
+ return result->ice_invocationTimeout(prx->ice_getInvocationTimeout());
+}
+
+//
+// Copies a set of properties
+//
+void
+copyProperties(const string& prefix, const PropertiesPtr& from, const PropertiesPtr& to)
+{
+ PropertyDict dict = from->getPropertiesForPrefix(prefix);
+ for(PropertyDict::const_iterator p = dict.begin(); p != dict.end(); ++p)
+ {
+ to->setProperty(p->first, p->second);
+ }
+}
+
+//
+// Create communicator used to send logs
+//
+CommunicatorPtr
+createSendLogCommunicator(const CommunicatorPtr& communicator, const LoggerPtr& logger)
+{
+ InitializationData initData;
+ initData.logger = logger;
+ initData.properties = createProperties();
+
+ PropertiesPtr mainProps = communicator->getProperties();
+
+ copyProperties("Ice.Default.Locator", mainProps, initData.properties);
+ copyProperties("Ice.Plugin.IceSSL", mainProps, initData.properties);
+ copyProperties("IceSSL.", mainProps, initData.properties);
+
+ StringSeq extraProps = mainProps->getPropertyAsList("Ice.Admin.Logger.Properties");
+
+ if(!extraProps.empty())
+ {
+ for(vector<string>::iterator p = extraProps.begin(); p != extraProps.end(); ++p)
+ {
+ if(p->find("--") != 0)
+ {
+ *p = "--" + *p;
+ }
+ }
+ initData.properties->parseCommandLineOptions("", extraProps);
+ }
+ return initialize(initData);
+}
//
// LoggerAdminI
//
-LoggerAdminI::LoggerAdminI(const string& name, const Ice::PropertiesPtr& props) :
+LoggerAdminI::LoggerAdminI(const string& name, const PropertiesPtr& props) :
_facetName(name),
_logCount(0),
_maxLogCount(props->getPropertyAsIntWithDefault("Ice.Admin.Logger.KeepLogs", 100)),
_traceCount(0),
_maxTraceCount(props->getPropertyAsIntWithDefault("Ice.Admin.Logger.KeepTraces", 100)),
_traceLevel(props->getPropertyAsInt("Ice.Trace.Admin.Logger")),
- _remoteCallCompleted(Ice::newCallback(this, &LoggerAdminI::remoteCallCompleted)),
- _destroyed(false),
- _pingThreadStarted(false)
+ _remoteCallCompleted(newCallback(this, &LoggerAdminI::remoteCallCompleted))
{
- int pingPeriod = props->getPropertyAsIntWithDefault("Ice.Admin.Logger.PingPeriod", 60);
- if(pingPeriod < 10)
- {
- pingPeriod = 10;
- }
- _pingPeriod = IceUtil::Time::seconds(pingPeriod);
-
_oldestLog = _queue.end();
_oldestTrace = _queue.end();
}
void
-LoggerAdminI::attachRemoteLogger(const Ice::RemoteLoggerPrx& prx,
- const Ice::LogMessageTypeSeq& messageTypes,
- const Ice::StringSeq& categories,
- Ice::Int messageMax,
- const Ice::Current& current)
+LoggerAdminI::attachRemoteLogger(const RemoteLoggerPrx& prx,
+ const LogMessageTypeSeq& messageTypes,
+ const StringSeq& categories,
+ Int messageMax,
+ const Current& current)
{
- if(prx == 0)
+ if(!prx)
{
return; // can't send this null RemoteLogger anything!
}
+
+ LoggerAdminLoggerIPtr logger = LoggerAdminLoggerIPtr::dynamicCast(current.adapter->getCommunicator()->getLogger());
+ if(!logger)
+ {
+ // Our logger is not installed - must be a bug
+ assert(0);
+ return;
+ }
- Ice::RemoteLoggerPrx remoteLogger = prx->ice_oneway();
- Filters filters(messageTypes, categories);
-
- Ice::LogMessageSeq initLogMessages;
- Ice::LoggerPtr logger = current.adapter->getCommunicator()->getLogger();
+ RemoteLoggerPrx remoteLogger = prx->ice_twoway();
+ // TODO set invocation timeout
+ Filters filters(messageTypes, categories);
+ LogMessageSeq initLogMessages;
{
- IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
-
- if(_remoteLoggerMap.insert(make_pair(remoteLogger, filters)).second == false)
+ IceUtil::Mutex::Lock lock(_mutex);
+
+ if(!_sendLogCommunicator)
+ {
+ _sendLogCommunicator =
+ createSendLogCommunicator(current.adapter->getCommunicator(), logger->getLocalLogger());
+ }
+
+ if(!_remoteLoggerMap.insert(make_pair(changeCommunicator(remoteLogger, _sendLogCommunicator), filters)).second)
{
if(_traceLevel > 0)
{
- Ice::Trace trace(current.adapter->getCommunicator()->getLogger(), _facetName);
- trace << "rejecting '" << remoteLogger << "' with RemoteLoggerAlreadyAttachedException";
+ Trace trace(logger, _facetName);
+ trace << "rejecting `" << remoteLogger << "' with RemoteLoggerAlreadyAttachedException";
}
- throw Ice::RemoteLoggerAlreadyAttachedException();
- }
-
- if(_pingThreadStarted == false)
- {
- IceUtil::ThreadPtr t = new PingThread(this, logger);
- _pingThreadControl = t->start();
- _pingThreadStarted = true;
+ throw RemoteLoggerAlreadyAttachedException();
}
if(messageMax != 0)
@@ -337,17 +386,17 @@ LoggerAdminI::attachRemoteLogger(const Ice::RemoteLoggerPrx& prx,
if(_traceLevel > 0)
{
- Ice::Trace trace(logger, _facetName);
- trace << "sending init to '" << remoteLogger->ice_twoway() << "'";
+ Trace trace(logger, _facetName);
+ trace << "attached `" << remoteLogger << "'";
}
filterLogMessages(initLogMessages, filters.messageTypes, filters.traceCategories, messageMax);
try
{
- remoteLogger->ice_twoway()->begin_init(logger->getPrefix(), initLogMessages, _remoteCallCompleted, logger);
+ remoteLogger->begin_init(logger->getPrefix(), initLogMessages, _remoteCallCompleted, logger);
}
- catch(const Ice::LocalException& ex)
+ catch(const LocalException& ex)
{
deadRemoteLogger(remoteLogger, logger, ex, "init");
throw;
@@ -355,36 +404,38 @@ LoggerAdminI::attachRemoteLogger(const Ice::RemoteLoggerPrx& prx,
}
void
-LoggerAdminI::detachRemoteLogger(const Ice::RemoteLoggerPrx& remoteLogger,
- const Ice::Current& current)
+LoggerAdminI::detachRemoteLogger(const RemoteLoggerPrx& remoteLogger, const Current& current)
{
if(remoteLogger == 0)
{
- throw Ice::RemoteLoggerNotAttachedException();
+ throw RemoteLoggerNotAttachedException();
}
+ //
+ // No need to convert the proxy as we only use its identity
+ //
bool found = removeRemoteLogger(remoteLogger);
if(!found)
{
- throw Ice::RemoteLoggerNotAttachedException();
+ throw RemoteLoggerNotAttachedException();
}
if(_traceLevel > 0)
{
- Ice::Trace trace(current.adapter->getCommunicator()->getLogger(), _facetName);
- trace << "detached '" << remoteLogger << "'";
+ Trace trace(current.adapter->getCommunicator()->getLogger(), _facetName);
+ trace << "detached `" << remoteLogger << "'";
}
}
-Ice::LogMessageSeq
-LoggerAdminI::getLog(const Ice::LogMessageTypeSeq& messageTypes,
- const Ice::StringSeq& categories,
- Ice::Int messageMax, string& prefix, const Ice::Current& current)
+LogMessageSeq
+LoggerAdminI::getLog(const LogMessageTypeSeq& messageTypes,
+ const StringSeq& categories,
+ Int messageMax, string& prefix, const Current& current)
{
- Ice::LogMessageSeq logMessages;
+ LogMessageSeq logMessages;
{
- IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+ IceUtil::Mutex::Lock lock(_mutex);
if(messageMax != 0)
{
@@ -392,7 +443,7 @@ LoggerAdminI::getLog(const Ice::LogMessageTypeSeq& messageTypes,
}
}
- Ice::LoggerPtr logger = current.adapter->getCommunicator()->getLogger();
+ LoggerPtr logger = current.adapter->getCommunicator()->getLogger();
prefix = logger->getPrefix();
Filters filters(messageTypes, categories);
@@ -400,22 +451,33 @@ LoggerAdminI::getLog(const Ice::LogMessageTypeSeq& messageTypes,
return logMessages;
}
-vector<Ice::RemoteLoggerPrx>
-LoggerAdminI::log(const Ice::LogMessage& logMessage)
+void
+LoggerAdminI::destroy()
{
- vector<Ice::RemoteLoggerPrx> remoteLoggers;
+ IceUtil::Mutex::Lock lock(_mutex);
+ if(_sendLogCommunicator)
+ {
+ _sendLogCommunicator->destroy();
+ _sendLogCommunicator = 0;
+ }
+}
+
+vector<RemoteLoggerPrx>
+LoggerAdminI::log(const LogMessage& logMessage)
+{
+ vector<RemoteLoggerPrx> remoteLoggers;
- IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+ IceUtil::Mutex::Lock lock(_mutex);
//
// Put message in _queue
//
- if((logMessage.type != Ice::TraceMessage && _maxLogCount > 0) ||
- (logMessage.type == Ice::TraceMessage && _maxTraceCount > 0))
+ if((logMessage.type != TraceMessage && _maxLogCount > 0) ||
+ (logMessage.type == TraceMessage && _maxTraceCount > 0))
{
- list<Ice::LogMessage>::iterator p = _queue.insert(_queue.end(), logMessage);
+ list<LogMessage>::iterator p = _queue.insert(_queue.end(), logMessage);
- if(logMessage.type != Ice::TraceMessage)
+ if(logMessage.type != TraceMessage)
{
assert(_maxLogCount > 0);
if(_logCount == _maxLogCount)
@@ -425,7 +487,7 @@ LoggerAdminI::log(const Ice::LogMessage& logMessage)
//
assert(_oldestLog != _queue.end());
_oldestLog = _queue.erase(_oldestLog);
- while(_oldestLog != _queue.end() && _oldestLog->type == Ice::TraceMessage)
+ while(_oldestLog != _queue.end() && _oldestLog->type == TraceMessage)
{
_oldestLog++;
}
@@ -451,7 +513,7 @@ LoggerAdminI::log(const Ice::LogMessage& logMessage)
//
assert(_oldestTrace != _queue.end());
_oldestTrace = _queue.erase(_oldestTrace);
- while(_oldestTrace != _queue.end() && _oldestTrace->type != Ice::TraceMessage)
+ while(_oldestTrace != _queue.end() && _oldestTrace->type != TraceMessage)
{
_oldestTrace++;
}
@@ -477,7 +539,7 @@ LoggerAdminI::log(const Ice::LogMessage& logMessage)
if(filters.messageTypes.empty() || filters.messageTypes.count(logMessage.type) != 0)
{
- if(logMessage.type != Ice::TraceMessage || filters.traceCategories.empty() ||
+ if(logMessage.type != TraceMessage || filters.traceCategories.empty() ||
filters.traceCategories.count(logMessage.traceCategory) != 0)
{
remoteLoggers.push_back(p->first);
@@ -489,109 +551,33 @@ LoggerAdminI::log(const Ice::LogMessage& logMessage)
}
void
-LoggerAdminI::deadRemoteLogger(const Ice::RemoteLoggerPrx& remoteLogger,
- const Ice::LoggerPtr& logger,
- const Ice::LocalException& ex,
+LoggerAdminI::deadRemoteLogger(const RemoteLoggerPrx& remoteLogger,
+ const LoggerPtr& logger,
+ const LocalException& ex,
const string& operation)
{
+ //
+ // No need to convert remoteLogger as we only use its identity
+ //
if(removeRemoteLogger(remoteLogger))
{
if(_traceLevel > 0)
{
- Ice::Trace trace(logger, _facetName);
- trace << operation << " on '" << remoteLogger << "' raised '"
- << ex << "'; remote logger removed automatically";
- }
- }
-}
-
-void
-LoggerAdminI::destroy()
-{
- IceUtil::ThreadControl pingThreadControl;
- bool joinThread = false;
- {
- IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
-
- if(_pingThreadStarted)
- {
- joinThread = true;
- pingThreadControl = _pingThreadControl;
- _pingThreadStarted = false;
- _destroyed = true;
- _monitor.notifyAll();
+ Trace trace(logger, _facetName);
+ trace << "detached `" << remoteLogger << "' because " << operation << " raised:\n" << ex;
}
}
-
- if(joinThread)
- {
- pingThreadControl.join();
- }
-}
-
-void
-LoggerAdminI::run(const Ice::LoggerPtr& logger)
-{
- if(_traceLevel > 1)
- {
- Ice::Trace trace(logger, _facetName);
- trace << "Ping thread started";
- }
-
- for(;;)
- {
- vector<Ice::RemoteLoggerPrx> remoteLoggers;
- {
- IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
- if(_destroyed)
- {
- break; // for(;;)
- }
-
- if(_monitor.timedWait(_pingPeriod) == false && !_destroyed)
- {
- transform(_remoteLoggerMap.begin(), _remoteLoggerMap.end(), back_inserter(remoteLoggers),
- GetRemoteLoggerMapKey());
- }
- }
-
- for(vector<Ice::RemoteLoggerPrx>::const_iterator p = remoteLoggers.begin(); p != remoteLoggers.end(); ++p)
- {
- Ice::RemoteLoggerPrx remoteLogger = (*p)->ice_twoway();
-
- if(_traceLevel > 1)
- {
- Ice::Trace trace(logger, _facetName);
- trace << "sending ice_ping to '" << remoteLogger << "'";
- }
-
- try
- {
- remoteLogger->begin_ice_ping(_remoteCallCompleted, logger);
- }
- catch(const Ice::LocalException& ex)
- {
- deadRemoteLogger(remoteLogger, logger, ex, "ice_ping");
- }
- }
- }
-
- if(_traceLevel > 1)
- {
- Ice::Trace trace(logger, _facetName);
- trace << "Ping thread completed";
- }
}
bool
-LoggerAdminI::removeRemoteLogger(const Ice::RemoteLoggerPrx& remoteLogger)
+LoggerAdminI::removeRemoteLogger(const RemoteLoggerPrx& remoteLogger)
{
- IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+ IceUtil::Mutex::Lock lock(_mutex);
return _remoteLoggerMap.erase(remoteLogger) > 0;
}
void
-LoggerAdminI::remoteCallCompleted(const Ice::AsyncResultPtr& r)
+LoggerAdminI::remoteCallCompleted(const AsyncResultPtr& r)
{
try
{
@@ -599,35 +585,19 @@ LoggerAdminI::remoteCallCompleted(const Ice::AsyncResultPtr& r)
if(_traceLevel > 1)
{
- Ice::LoggerPtr logger = Ice::LoggerPtr::dynamicCast(r->getCookie());
- Ice::Trace trace(logger, _facetName);
- trace << r->getOperation() << " on '" << r->getProxy() << "' completed successfully";
+ LoggerPtr logger = LoggerPtr::dynamicCast(r->getCookie());
+ Trace trace(logger, _facetName);
+ trace << r->getOperation() << " on `" << r->getProxy() << "' completed successfully";
}
}
- catch(const Ice::LocalException& ex)
+ catch(const LocalException& ex)
{
- deadRemoteLogger(Ice::RemoteLoggerPrx::uncheckedCast(r->getProxy()),
- Ice::LoggerPtr::dynamicCast(r->getCookie()),
- ex, r->getOperation());
+ deadRemoteLogger(RemoteLoggerPrx::uncheckedCast(r->getProxy()),
+ LoggerPtr::dynamicCast(r->getCookie()),
+ ex, r->getOperation());
}
}
-//
-// PingThread
-//
-PingThread::PingThread(
- const LoggerAdminIPtr& loggerAdmin, const Ice::LoggerPtr& logger) :
- IceUtil::Thread("Ice.RemoteLoggerPingThread"),
- _loggerAdmin(loggerAdmin),
- _logger(logger)
-{
-}
-
-void
-PingThread::run()
-{
- _loggerAdmin->run(_logger);
-}
//
@@ -635,12 +605,11 @@ PingThread::run()
//
LoggerAdminLoggerI::LoggerAdminLoggerI(const string& facetName,
- const Ice::PropertiesPtr& props,
- const Ice::LoggerPtr& localLogger) :
+ const PropertiesPtr& props,
+ const LoggerPtr& localLogger) :
_localLogger(localLogger),
_loggerAdmin(new LoggerAdminI(facetName, props)),
- _destroyed(false),
- _sendLogThreadStarted(false)
+ _destroyed(false)
{
//
// There is currently no way to have a null local logger
@@ -651,10 +620,7 @@ LoggerAdminLoggerI::LoggerAdminLoggerI(const string& facetName,
void
LoggerAdminLoggerI::print(const string& message)
{
- Ice::LogMessage logMessage = {Ice::PrintMessage,
- IceUtil::Time::now().toMicroSeconds(),
- "",
- message};
+ LogMessage logMessage = { PrintMessage, IceUtil::Time::now().toMicroSeconds(), "", message };
_localLogger->print(message);
log(logMessage);
@@ -663,10 +629,7 @@ LoggerAdminLoggerI::print(const string& message)
void
LoggerAdminLoggerI::trace(const string& category, const string& message)
{
- Ice::LogMessage logMessage = {Ice::TraceMessage,
- IceUtil::Time::now().toMicroSeconds(),
- category,
- message};
+ LogMessage logMessage = { TraceMessage, IceUtil::Time::now().toMicroSeconds(), category, message };
_localLogger->trace(category, message);
log(logMessage);
@@ -675,11 +638,7 @@ LoggerAdminLoggerI::trace(const string& category, const string& message)
void
LoggerAdminLoggerI::warning(const string& message)
{
- Ice::LogMessage logMessage = {Ice::WarningMessage,
- IceUtil::Time::now().toMicroSeconds(),
- "",
- message};
-
+ LogMessage logMessage = { WarningMessage, IceUtil::Time::now().toMicroSeconds(), "", message };
_localLogger->warning(message);
log(logMessage);
@@ -688,11 +647,7 @@ LoggerAdminLoggerI::warning(const string& message)
void
LoggerAdminLoggerI::error(const string& message)
{
- Ice::LogMessage logMessage = {Ice::ErrorMessage,
- IceUtil::Time::now().toMicroSeconds(),
- "",
- message};
-
+ LogMessage logMessage = { ErrorMessage, IceUtil::Time::now().toMicroSeconds(), "", message };
_localLogger->error(message);
log(logMessage);
@@ -704,69 +659,51 @@ LoggerAdminLoggerI::getPrefix()
return _localLogger->getPrefix();
}
-Ice::LoggerPtr
+LoggerPtr
LoggerAdminLoggerI::cloneWithPrefix(const string& prefix)
{
return _localLogger->cloneWithPrefix(prefix);
}
void
-LoggerAdminLoggerI::addAdminFacet(const Ice::CommunicatorPtr& communicator)
+LoggerAdminLoggerI::addAdminFacet(const CommunicatorPtr& communicator)
{
communicator->addAdminFacet(_loggerAdmin, _loggerAdmin->getFacetName());
}
void
-LoggerAdminLoggerI::log(const Ice::LogMessage& logMessage)
+LoggerAdminLoggerI::log(const LogMessage& logMessage)
{
-
- //
- // We don't want to proceed if the SendLog thread is calling log.
- //
- bool proceed = false;
+ const vector<RemoteLoggerPrx> remoteLoggers = _loggerAdmin->log(logMessage);
+
+ if(!remoteLoggers.empty())
{
- IceUtil::ThreadControl currentThread;
-
IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
- proceed = !_destroyed &&
- (!_sendLogThreadStarted || (_sendLogThreadStarted && (currentThread != _sendLogThreadControl)));
- }
-
- if(proceed)
- {
- const vector<Ice::RemoteLoggerPrx> remoteLoggers = _loggerAdmin->log(logMessage);
-
- if(!remoteLoggers.empty())
+
+ if(!_sendLogThread)
{
- IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
-
- if(!_sendLogThreadStarted)
- {
- IceUtil::ThreadPtr t = new SendLogThread(this);
- _sendLogThreadControl = t->start();
- _sendLogThreadStarted = true;
- }
- _jobQueue.push_back(new Job(remoteLoggers, logMessage));
- _monitor.notifyAll();
+ _sendLogThread = new SendLogThread(this);
+ _sendLogThread->start();
}
+
+ _jobQueue.push_back(new Job(remoteLoggers, logMessage));
+ _monitor.notifyAll();
}
}
void
LoggerAdminLoggerI::destroy()
{
- _loggerAdmin->destroy();
-
IceUtil::ThreadControl sendLogThreadControl;
bool joinThread = false;
{
IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
- if(_sendLogThreadStarted)
+ if(_sendLogThread)
{
joinThread = true;
- sendLogThreadControl = _sendLogThreadControl;
- _sendLogThreadStarted = false;
+ sendLogThreadControl = _sendLogThread->getThreadControl();
+ _sendLogThread = 0;
_destroyed = true;
_monitor.notifyAll();
}
@@ -776,6 +713,9 @@ LoggerAdminLoggerI::destroy()
{
sendLogThreadControl.join();
}
+
+ // destroy sendLogCommunicator
+ _loggerAdmin->destroy();
}
void
@@ -783,8 +723,8 @@ LoggerAdminLoggerI::run()
{
if(_loggerAdmin->getTraceLevel() > 1)
{
- Ice::Trace trace(_localLogger, _loggerAdmin->getFacetName());
- trace << "Send log thread started";
+ Trace trace(_localLogger, _loggerAdmin->getFacetName());
+ trace << "send log thread started";
}
for(;;)
@@ -798,42 +738,38 @@ LoggerAdminLoggerI::run()
{
break; // for(;;)
}
- if(!_jobQueue.empty())
+
+ assert(!_jobQueue.empty());
+ JobPtr job = _jobQueue.front();
+ _jobQueue.pop_front();
+ lock.release();
+
+ for(vector<RemoteLoggerPrx>::const_iterator p = job->remoteLoggers.begin(); p != job->remoteLoggers.end(); ++p)
{
- JobPtr job = _jobQueue.front();
- _jobQueue.pop_front();
- lock.release();
+ if(_loggerAdmin->getTraceLevel() > 1)
+ {
+ Trace trace(_localLogger, _loggerAdmin->getFacetName());
+ trace << "sending log message to `" << *p << "'";
+ }
- for(vector<Ice::RemoteLoggerPrx>::const_iterator p = job->remoteLoggers.begin();
- p != job->remoteLoggers.end(); ++p)
+ try
{
- if(_loggerAdmin->getTraceLevel() > 1)
- {
- Ice::Trace trace(_localLogger, _loggerAdmin->getFacetName());
- trace << "sending log message to '" << *p << "'";
- }
-
- try
- {
- // We use a synchronous oneway call here
- // using twoway could generate additional log when receiving the response
- // from the client thread-pool thread; likewise, AMI could generate
- // extra logs from the client thread pool thread
-
- (*p)->log(job->logMessage);
- }
- catch(const Ice::LocalException& ex)
- {
- _loggerAdmin->deadRemoteLogger(*p, _localLogger, ex, "log");
- }
- }
- }
+ //
+ // *p is a proxy associated with the _sendLogCommunicator
+ //
+ (*p)->begin_log(job->logMessage, _loggerAdmin->getRemoteCallCompleted(), _localLogger);
+ }
+ catch(const LocalException& ex)
+ {
+ _loggerAdmin->deadRemoteLogger(*p, _localLogger, ex, "log");
+ }
+ }
}
if(_loggerAdmin->getTraceLevel() > 1)
{
- Ice::Trace trace(_localLogger, _loggerAdmin->getFacetName());
- trace << "Send log thread completed";
+ Trace trace(_localLogger, _loggerAdmin->getFacetName());
+ trace << "send log thread completed";
}
}
@@ -862,10 +798,10 @@ SendLogThread::run()
namespace IceInternal
{
-Ice::LoggerAdminLoggerPtr
-createLoggerAdminLogger(const std::string& facetName,
- const Ice::PropertiesPtr& props,
- const Ice::LoggerPtr& localLogger)
+LoggerAdminLoggerPtr
+createLoggerAdminLogger(const string& facetName,
+ const PropertiesPtr& props,
+ const LoggerPtr& localLogger)
{
return new LoggerAdminLoggerI(facetName, props, localLogger);
}
diff --git a/cpp/src/Ice/PropertyNames.cpp b/cpp/src/Ice/PropertyNames.cpp
index 01a2761c583..e5b2f8e567c 100644
--- a/cpp/src/Ice/PropertyNames.cpp
+++ b/cpp/src/Ice/PropertyNames.cpp
@@ -6,7 +6,7 @@
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************
-// Generated by makeprops.py from file ../config/PropertyNames.xml, Fri Aug 29 11:20:17 2014
+// Generated by makeprops.py from file ../config/PropertyNames.xml, Tue Sep 2 12:07:05 2014
// IMPORTANT: Do not edit this file -- any edits made here will be lost!
@@ -70,7 +70,7 @@ const IceInternal::Property IcePropsData[] =
IceInternal::Property("Ice.Admin.Logger", false, 0),
IceInternal::Property("Ice.Admin.Logger.KeepLogs", false, 0),
IceInternal::Property("Ice.Admin.Logger.KeepTraces", false, 0),
- IceInternal::Property("Ice.Admin.Logger.PingPeriod", false, 0),
+ IceInternal::Property("Ice.Admin.Logger.Properties", false, 0),
IceInternal::Property("Ice.Admin.ServerId", false, 0),
IceInternal::Property("Ice.BackgroundLocatorCacheUpdates", false, 0),
IceInternal::Property("Ice.BatchAutoFlush", false, 0),
diff --git a/cpp/src/Ice/PropertyNames.h b/cpp/src/Ice/PropertyNames.h
index 5d17c24f3c3..6eebeed1e10 100644
--- a/cpp/src/Ice/PropertyNames.h
+++ b/cpp/src/Ice/PropertyNames.h
@@ -6,7 +6,7 @@
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************
-// Generated by makeprops.py from file ../config/PropertyNames.xml, Fri Aug 29 11:20:17 2014
+// Generated by makeprops.py from file ../config/PropertyNames.xml, Tue Sep 2 12:07:05 2014
// IMPORTANT: Do not edit this file -- any edits made here will be lost!
@@ -25,9 +25,9 @@ struct Property
const char* deprecatedBy;
Property(const char* n, bool d, const char* b) :
- pattern(n),
- deprecated(d),
- deprecatedBy(b)
+ pattern(n),
+ deprecated(d),
+ deprecatedBy(b)
{
}
generated by cgit v1.2.3 (git 2.46.0) at 2025-08-03 22:54:26 +0000