27 #include <zypp-core/zyppng/io/Socket> 28 #include <zypp-core/zyppng/io/SockAddr> 29 #include <zypp-core/zyppng/base/EventLoop> 30 #include <zypp-core/zyppng/base/EventDispatcher> 31 #include <zypp-core/zyppng/base/Timer> 33 #include <zypp-core/zyppng/thread/Wakeup> 35 #include <zypp-core/zyppng/base/SocketNotifier> 44 #include <sys/types.h> 71 std::this_thread::yield();
112 if (
_thread.get_id() != std::this_thread::get_id() )
131 _thread = std::thread( [
this] () {
147 std::vector<zyppng::Socket::Ptr> clients;
150 server->bind( std::make_shared<zyppng::UnixSockAddr>(
sockPath(),
true ) );
156 auto cl = server->accept();
158 clients.push_back( cl );
164 if ( !writer )
return;
165 while ( sock->canReadLine() ) {
166 auto br = sock->readLine();
167 writer->writeOut( std::string( br.data(), br.size() - 1 ) );
173 auto lock = sock.lock();
177 auto idx = std::find_if( clients.begin(), clients.end(), [lock](
const auto &s ){
return lock.get() == s.get(); } );
178 clients.erase( idx );
192 for (
auto &sock : clients ){
193 auto br = sock->readLine();
194 while ( !br.empty() ) {
195 if ( br.back () ==
'\n' )
196 writer->writeOut( std::string( br.data(), br.size() - 1 ) );
198 writer->writeOut( std::string( br.data(), br.size() ) );
200 br = sock->readLine();
241 _sockFD = ::socket( AF_UNIX, SOCK_STREAM, 0 );
267 writer->writeOut( msg );
274 if ( msg.back() !=
'\n' )
278 while ( written < msg.size() ) {
307 static constexpr std::string_view
OO {
"\033[0m" };
308 static constexpr std::string_view
WH {
"\033[37;40m" };
309 static constexpr std::string_view
CY {
"\033[36;40m" };
310 static constexpr std::string_view
YE {
"\033[33;1;40m" };
311 static constexpr std::string_view
GR {
"\033[32;40m" };
312 static constexpr std::string_view
RE {
"\033[31;1;40m" };
313 static constexpr std::string_view
MA {
"\033[35;40m" };
317 std::string
tracestr(
char tag_r,
unsigned depth_r,
const std::string & msg_r,
const char * file_r,
const char * fnc_r,
int line_r )
319 static str::Format fmt {
"***%2d %s%c %s(%s):%d %s" };
320 fmt % depth_r %std::string(depth_r,
'.') % tag_r %
Pathname::basename(file_r) % fnc_r % line_r % msg_r;
328 , _msg(
std::move(msg_r) )
330 unsigned depth =
_depth++;
332 Osd(
L_USR(
"TRACE"),depth) << m << endl;
337 unsigned depth = --
_depth;
339 Osd(
L_USR(
"TRACE"),depth) << m << endl;
343 : _strout { std::cerr }
345 { _strout << (i?
WH:
YE); }
357 #endif // ZYPP_NDEBUG 383 int fd = ::open( file_r.
c_str(), O_CREAT|O_EXCL, mode_r );
388 std::ofstream * fstr = 0;
389 _outs.reset( (fstr =
new std::ofstream( file_r.
asString().c_str(), std::ios_base::app )) );
390 fstr->rdbuf()->pubsetbuf(0,0);
407 const char * file_r,
const char * func_r,
int line_r,
408 const std::string & buffer_r );
439 void tagSet(
const char * fil_r,
const char * fnc_r,
int lne_r )
448 std::streamsize
xsputn(
const char * s, std::streamsize n )
override 461 virtual int writeout(
const char* s, std::streamsize n )
468 for (
int i = 0; i < n; ++i, ++c )
471 _buffer += std::string( s, c-s );
479 _buffer += std::string( s, c-s );
505 :
_mybuf( group_r, level_r )
520 std::ostream &
getStream(
const char * fil_r,
const char * fnc_r,
int lne_r )
545 static thread_local
int logControlValid = 0;
546 return logControlValid;
586 return impl ? impl->hideThreadName() :
false;
592 if ( impl ) impl->hideThreadName( onOff_r );
599 return impl ? impl->_logToPPIDMode :
false;
607 impl->_logToPPIDMode = onOff_r;
628 if ( logfile_r.
empty() )
630 else if ( logfile_r ==
Pathname(
"-" ) )
666 ret <<
"---<RESET LOGSTREAM FROM FAILED STATE]" << endl;
681 const std::string & message_r )
684 file_r, func_r, line_r,
699 if ( getenv(
"ZYPP_LOGFILE") )
700 logfile( getenv(
"ZYPP_LOGFILE") );
702 if ( getenv(
"ZYPP_PROFILING") )
759 return str <<
"LogControlImpl";
774 static std::ostream nstream(NULL);
776 if ( !control || !group_r || strlen(group_r ) == 0 ) {
782 return control->getStream( group_r,
791 const char * file_r,
const char * func_r,
int line_r,
792 const std::string & buffer_r )
798 control->putStream( group_r, level_r,
799 file_r, func_r, line_r,
808 return impl->isExcessive();
815 using logger::LogControlImpl;
825 const std::string & message_r )
827 static char hostname[1024];
828 static char nohostname[] =
"unknown";
834 ret =
str::form(
"%s <%d> %s(%d) [%s] %s(%s):%d %s",
835 now.c_str(), level_r,
836 ( gethostname( hostname, 1024 ) ? nohostname : hostname ),
839 file_r, func_r, line_r,
842 ret =
str::form(
"%s <%d> %s(%d) [%s] %s(%s):%d {T:%s} %s",
843 now.c_str(), level_r,
844 ( gethostname( hostname, 1024 ) ? nohostname : hostname ),
845 logToPPID ? getppid() : getpid(),
847 file_r, func_r, line_r,
867 impl->logfile( logfile_r );
876 impl->logfile( logfile_r, mode_r );
885 return impl->getLineWriter();
893 impl->setLineWriter( writer_r );
901 impl->setLineFormater( formater_r );
914 impl->setLineWriter( shared_ptr<LineWriter>() );
950 impl->excessive(
true );
957 impl->excessive(
false );
LogControlImpl & operator=(const LogControlImpl &)=delete
void enableLogForwardingMode(bool enable=true)
std::atomic_flag _atomicLock
Osd & operator<<(Tp &&val)
LogClient & operator=(const LogClient &)=delete
static Ptr create(int domain, int type, int protocol)
LogLevel
Definition of log levels.
boost::logic::tribool TriBool
3-state boolean logic (true, false and indeterminate).
constexpr bool always_false_v
std::ostream & getStream(const std::string &group_r, LogLevel level_r, const char *file_r, const char *func_r, const int line_r)
Provide the log stream to write (logger interface)
static constexpr std::string_view MA
Base class for ostream based LineWriter.
static bool instanceHideThreadName()
void tagSet(const char *fil_r, const char *fnc_r, int lne_r)
Loglinestream(const std::string &group_r, LogLevel level_r)
static void instanceSetLogToPPID(bool onOff_r)
bool trySocketConnection(int &sockFD, const SockAddr &addr, uint64_t timeout)
const std::string & name() const
static constexpr std::string_view WH
const char * c_str() const
String representation.
String related utilities and Regular expression matching.
SignalProxy< void()> sigIncomingConnection()
void excessive(bool onOff_r)
static void instanceHideThreadName(bool onOff_r)
std::string basename() const
Return the last component of this path.
std::string form(const char *format,...) __attribute__((format(printf
Printf style construction of std::string.
LogControlImpl()
Singleton ctor.
Osd(std::ostream &, int=0)
void setLineWriter(const shared_ptr< LogControl::LineWriter > &writer_r)
NULL _lineWriter indicates no loggin.
static std::string sockPath()
void logfile(const Pathname &logfile_r, mode_t mode_r=0640)
void logfile(const Pathname &logfile_r)
Set path for the logfile.
LogThread & operator=(const LogThread &)=delete
void setLineWriter(const shared_ptr< LineWriter > &writer_r)
Assign a LineWriter.
std::shared_ptr< Socket > Ptr
std::string tracestr(char tag_r, unsigned depth_r, const std::string &msg_r, const char *file_r, const char *fnc_r, int line_r)
bool _logToPPIDMode
Hint for formatter to use the PPID and always show the thread name.
void logToStdErr()
Log to std::err.
bool empty() const
Test for an empty path.
TraceLeave(const TraceLeave &)=delete
std::shared_ptr< SocketNotifier > makeNotifier(const bool enabled=true) const
std::thread::id threadId()
int overflow(int ch=EOF) override
static bool instanceLogToPPID()
Hint for formatter wether we forward all logs to a parents log.
shared_ptr< LogControl::LineWriter > getLineWriter() const
zyppng::Wakeup _stopSignal
const std::string & asString() const
String representation.
shared_ptr< Loglinestream > StreamPtr
static constexpr std::string_view GR
friend std::ostream & operator<<(std::ostream &str, const LogControl &obj)
Loglinebuf & operator=(const Loglinebuf &)=default
static constexpr std::string_view YE
void setLineFormater(const shared_ptr< LogControl::LineFormater > &format_r)
Assert _lineFormater is not NULL.
shared_ptr< LogControl::LineFormater > _lineFormater
std::ostream & getStream(const char *fil_r, const char *fnc_r, int lne_r)
bool hideThreadName() const
Hint for Formater whether to hide the thread name.
static LogControlImpl * instance()
The LogControlImpl singleton.
std::map< LogLevel, StreamPtr > StreamSet
boost::shared_ptr< log::LineWriter > _lineWriter
boost::shared_ptr< log::LineWriter > getLineWriter()
std::once_flag flagReadEnvAutomatically
void putRawLine(std::string &&line)
TriBool _hideThreadName
Hint for Formater whether to hide the thread name.
static constexpr std::string_view RE
std::map< std::string, StreamSet > StreamTable
Loglinebuf(std::string group_r, LogLevel level_r)
void logNothing()
Turn off logging.
void setLineWriter(boost::shared_ptr< log::LineWriter > writer)
Loglinestream & operator=(const Loglinestream &)=delete
void pushMessage(std::string msg)
std::streamsize xsputn(const char *s, std::streamsize n) override
static ZYPP_API ThreadData & current()
Maintain logfile related options.
virtual int writeout(const char *s, std::streamsize n)
static constexpr std::string_view OO
SignalProxy< void()> sigReadyRead()
static void notifyFork()
This will completely disable logging.
void putStream(const std::string &group_r, LogLevel level_r, const char *file_r, const char *func_r, int line_r, const std::string &buffer_r)
That's what Loglinebuf calls.
static Date now()
Return the current time.
auto eintrSafeCall(Fun &&function, Args &&... args)
void putStream(const std::string &group_r, LogLevel level_r, const char *file_r, const char *func_r, int line_r, const std::string &message_r)
Format and write out a logline from Loglinebuf.
void logRawLine(std::string &&line)
will push a line to the logthread without formatting it
void hideThreadName(bool onOff_r)
shared_ptr< LineWriter > getLineWriter() const
Get the current LineWriter.
Reference counted access to a Tp object calling a custom Dispose function when the last AutoDispose h...
SignalProxy< void(const SocketNotifier &sock, int evTypes)> sigActivated()
int & logControlValidFlag()
void setLineFormater(const shared_ptr< LineFormater > &formater_r)
Assign a LineFormater.
constexpr std::string_view ZYPP_MAIN_THREAD_NAME("Zypp-main")
std::ostream & getStream(const char *group_r, LogLevel level_r, const char *file_r, const char *func_r, const int line_r)
Return a log stream to write on.
Easy-to use interface to the ZYPP dependency resolver.
void emergencyShutdown()
will cause the log thread to exit and flush all sockets
bool blockAllSignalsForCurrentThread()
static constexpr std::string_view CY
zyppng::Socket::Ptr _sock
SignalProxy< void()> sigDisconnected()
static LogThread & instance()
LogControl implementation (thread_local Singleton).
FileLineWriter(const Pathname &file_r, mode_t mode_r=0)
std::ostream & operator<<(std::ostream &str, const LogControlImpl &)
StreamTable _streamtable
one streambuffer per group and level