change ivlog for add log to std setting. change IVSysMan, for save error log.

src/common/ivlog/ivlog.cpp

@@ -6,10 +6,14 @@
 
 namespace  iv {
 
+static int gminlevel = 0;
+static bool gbStdOut = false;
 
 Ivlog::Ivlog(const char * strmodulename)
 {
    ivlog_impl * p = new ivlog_impl(strmodulename);
+   gminlevel = p->GetMinLevel();
+   gbStdOut = p->GetbStdOut();
    p->start();
    mpimpl = (void *)p;
 }
@@ -30,6 +34,8 @@ va_end(ap) 用来清除list
 */
 void Ivlog::verbose(const char *str,...)
 {
+    if((gbStdOut== false) && (gminlevel > 0))return;
+
     va_list arg;
     char * strlog = new char[65636];
     std::shared_ptr<char> pstrlog; pstrlog.reset(strlog);
@@ -37,12 +43,21 @@ void Ivlog::verbose(const char *str,...)
     vsnprintf(strlog,65535,str,arg);
     va_end(arg);
 
+    if(gbStdOut)
+    {
+        std::cout<<strlog<<std::endl;
+    }
+
+    if(gminlevel>0)return;
+
     ivlog_impl * p = (ivlog_impl *)mpimpl;
     p->verbose(strlog);
 }
 
 void Ivlog::verbose(const char * strtag,const char *str,...)
 {
+    if((gbStdOut== false) && (gminlevel > 0))return;
+
     va_list arg;
     char * strlog = new char[65636];
     std::shared_ptr<char> pstrlog; pstrlog.reset(strlog);
@@ -50,103 +65,198 @@ void Ivlog::verbose(const char * strtag,const char *str,...)
     vsnprintf(strlog,65535,str,arg);
     va_end(arg);
 
+    if(gbStdOut)
+    {
+        std::cout<<strlog<<std::endl;
+    }
+
+
+    if(gminlevel>0)return;
+
     ivlog_impl * p = (ivlog_impl *)mpimpl;
     p->verbose(strlog,strtag);
 }
 
 void Ivlog::debug(const char *str,...)
 {
+    if((gbStdOut== false) && (gminlevel > 1))return;
+
+    ivlog_impl * p = (ivlog_impl *)mpimpl;
     va_list arg;
     char * strlog = new char[65636];
     std::shared_ptr<char> pstrlog; pstrlog.reset(strlog);
     va_start(arg, str);
     vsnprintf(strlog,65535,str,arg);
     va_end(arg);
-    ivlog_impl * p = (ivlog_impl *)mpimpl;
+
+    if(gbStdOut)
+    {
+        std::cout<<strlog<<std::endl;
+    }
+
+    if(gminlevel>1)return;
+
+
+
     p->debug(strlog);
 }
 
 void Ivlog::debug(const char * strtag,const char *str,...)
 {
+    if((gbStdOut== false) && (gminlevel > 1))return;
+
     va_list arg;
     char * strlog = new char[65636];
     std::shared_ptr<char> pstrlog; pstrlog.reset(strlog);
     va_start(arg, str);
     vsnprintf(strlog,65535,str,arg);
     va_end(arg);
+
+    if(gbStdOut)
+    {
+        std::cout<<strlog<<std::endl;
+    }
+
+    if(gminlevel>1)return;
     ivlog_impl * p = (ivlog_impl *)mpimpl;
+
     p->debug(strlog,strtag);
 }
 
 void Ivlog::info(const char *str,...)
 {
+    if((gbStdOut== false) && (gminlevel > 2))return;
+
     va_list arg;
     char * strlog = new char[65636];
     std::shared_ptr<char> pstrlog; pstrlog.reset(strlog);
     va_start(arg, str);
     vsnprintf(strlog,65535,str,arg);
     va_end(arg);
+
+    if(gbStdOut)
+    {
+        std::cout<<strlog<<std::endl;
+    }
+
+    if(gminlevel>2)return;
     ivlog_impl * p = (ivlog_impl *)mpimpl;
+
     p->info(strlog);
 }
 
 void Ivlog::info(const char * strtag,const char *str,...)
 {
+    if((gbStdOut== false) && (gminlevel > 2))return;
+
     va_list arg;
     char * strlog = new char[65636];
     std::shared_ptr<char> pstrlog; pstrlog.reset(strlog);
     va_start(arg, str);
     vsnprintf(strlog,65535,str,arg);
     va_end(arg);
+
+    if(gbStdOut)
+    {
+        std::cout<<strlog<<std::endl;
+    }
+
+    if(gminlevel>2)return;
     ivlog_impl * p = (ivlog_impl *)mpimpl;
+
     p->info(strlog,strtag);
 }
 
 void Ivlog::warn(const char *str,...)
 {
+    if((gbStdOut== false) && (gminlevel > 3))return;
+
     va_list arg;
     char * strlog = new char[65636];
     std::shared_ptr<char> pstrlog; pstrlog.reset(strlog);
     va_start(arg, str);
     vsnprintf(strlog,65535,str,arg);
     va_end(arg);
-   ivlog_impl * p = (ivlog_impl *)mpimpl;
+
+    if(gbStdOut)
+    {
+        std::cout<<strlog<<std::endl;
+    }
+
+    if(gminlevel>3)return;
+    ivlog_impl * p = (ivlog_impl *)mpimpl;
+
    p->warn(strlog);
 }
 
 void Ivlog::warn(const char * strtag,const char *str,...)
 {
+    if((gbStdOut== false) && (gminlevel > 3))return;
+
     va_list arg;
     char * strlog = new char[65636];
     std::shared_ptr<char> pstrlog; pstrlog.reset(strlog);
     va_start(arg, str);
     vsnprintf(strlog,65535,str,arg);
     va_end(arg);
-   ivlog_impl * p = (ivlog_impl *)mpimpl;
+
+    if(gbStdOut)
+    {
+        std::cout<<strlog<<std::endl;
+    }
+
+    if(gminlevel>3)return;
+    ivlog_impl * p = (ivlog_impl *)mpimpl;
+
    p->warn(strlog,strtag);
 }
 
 void Ivlog::error(const char *str,...)
 {
+    if((gbStdOut== false) && (gminlevel > 4))return;
+
     va_list arg;
     char * strlog = new char[65636];
     std::shared_ptr<char> pstrlog; pstrlog.reset(strlog);
     va_start(arg, str);
     vsnprintf(strlog,65535,str,arg);
     va_end(arg);
+
+    if(gbStdOut)
+    {
+        std::cout<<strlog<<std::endl;
+    }
+
+    if(gminlevel>4)return;
     ivlog_impl * p = (ivlog_impl *)mpimpl;
+
+
+
     p->error(strlog);
 }
 
 void Ivlog::error(const char * strtag, const char *str,...)
 {
+    if((gbStdOut== false) && (gminlevel > 4))return;
+
     va_list arg;
     char * strlog = new char[65636];
     std::shared_ptr<char> pstrlog; pstrlog.reset(strlog);
     va_start(arg, str);
     vsnprintf(strlog,65535,str,arg);
     va_end(arg);
+
+    if(gbStdOut)
+    {
+        std::cout<<strlog<<std::endl;
+    }
+
+
+    if(gminlevel>4)return;
     ivlog_impl * p = (ivlog_impl *)mpimpl;
+
+
+
     p->error(strlog,strtag);
 }
 

src/common/ivlog/ivlog_impl.cpp

@@ -7,6 +7,8 @@ ivlog_impl::ivlog_impl(const char * strmodulename)
 
     QString strlevel = configini->value("setting/level").toString();
 
+    QString strstdout = configini->value("setting/stdout").toString();
+
     if(strlevel == "")
     {
         mnMinLevel = 0;
@@ -17,7 +19,20 @@ ivlog_impl::ivlog_impl(const char * strmodulename)
         if(mnMinLevel<0)mnMinLevel = 0;
     }
 
+    if(strstdout == "")
+    {
+        mbStdOut = false;
+    }
+    else
+    {
+        if(strstdout == "true")
+        {
+            mbStdOut = true;
+        }
+    }
+
     qDebug("log level is %d",mnMinLevel);
+    std::cout<<"log stdout is "<<mbStdOut<<std::endl;
 
     delete configini;
 
@@ -155,6 +170,16 @@ int ivlog_impl::writelog(std::vector<iv::log::logdata> xvectorlog)
     return 0;
 }
 
+int ivlog_impl::GetMinLevel()
+{
+    return mnMinLevel;
+}
+
+bool ivlog_impl::GetbStdOut()
+{
+    return mbStdOut;
+}
+
 void ivlog_impl::run()
 {
     std::vector<iv::log::logdata> xvectorlog;

src/common/ivlog/ivlog_impl.h

@@ -46,6 +46,11 @@ private:
     int writelog(std::vector<iv::log::logdata>xvectorlog);
 
     int mnMinLevel = 0;
+    bool mbStdOut = false;
+
+public:
+    int GetMinLevel();
+    bool GetbStdOut();
 };
 
 #endif // IVLOG_IMPL_H

src/tool/IVSysMan/progmon.cpp

@@ -23,6 +23,7 @@ ProgMon::ProgMon(std::string path)
     InitLog();
 
     mpthread_stdout = new std::thread(&ProgMon::threadstdout,this);
+    mpthread_errout = new std::thread(&ProgMon::threaderrout,this);
 }
 
 ProgMon::~ProgMon()
@@ -41,6 +42,10 @@ ProgMon::~ProgMon()
     mbstdoutrun = false;
     mpthread_stdout->join();
 
+    std::cout<<"End Err out thread."<<std::endl;
+    mberroutrun = false;
+    mpthread_errout->join();
+
     if(mbFileStdLog)
     {
         mbFileStdLog = false;
@@ -116,6 +121,7 @@ std::vector<ProgUnit> ProgMon::loadprogunit(std::string path)
             std::string strargs = e.attribute("args","").toStdString();
             std::string strbstart = e.attribute("autostart","false").toStdString();
             std::string strgroup = e.attribute("group","unknown").toStdString();
+            std::string strsavestd = e.attribute("savestd","false").toStdString();
 
             ProgUnit x;
             if(strbstart == "true")x.mbautostart = true;
@@ -125,6 +131,8 @@ std::vector<ProgUnit> ProgMon::loadprogunit(std::string path)
             x.strargs = strargs;
             x.strgroup = strgroup;
             x.mProcess = 0;
+            x.mbSavestdout = false;
+            if(strsavestd == "true")x.mbSavestdout = true;
 
 
 
@@ -301,6 +309,11 @@ void ProgMon::onReadStandardError()
     QProcess * proc = (QProcess *)sender();
     QByteArray ba = proc->readAllStandardError();
 
+
+    mMutex_errout.lock();
+    if(mvectorerrout.size()<1000) mvectorerrout.push_back(stdoutunit(proc,ba));
+    mMutex_errout.unlock();
+
     return;
 
     if(ba.size() == 0)return;
@@ -663,6 +676,95 @@ void ProgMon::setquit()
     mbquit = true;
 }
 
+void ProgMon::threaderrout()
+{
+    QString strhomepath = getenv("HOME");
+
+    int nNeedCheckSpace = 0;
+
+    bool bHaveHDDSpace = true;
+
+    unsigned int i;
+
+    while(mberroutrun)
+    {
+
+
+        std::vector<stdoutunit> xvectorerrout;
+        mMutex_errout.lock();
+        xvectorerrout= mvectorerrout;
+        mvectorerrout.clear();
+        mMutex_errout.unlock();
+        if(xvectorerrout.size() == 0)
+        {
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        }
+        else
+        {
+
+            if(bHaveHDDSpace == false)
+            {
+                continue;
+            }
+            for(i=0;i<xvectorerrout.size();i++)
+            {
+                unsigned int j;
+                std::string strappname;
+                std::string strarg;
+                bool bFind = false;
+                mMutex.lock();
+                for(j=0;j<mvectorprog.size();j++)
+                {
+                    ProgUnit *pu = &(mvectorprog.at(j));
+                    if(xvectorerrout[i].mpProc == pu->mProcess)
+                    {
+                        strappname =  pu->strappname;
+                        strarg = pu->strargs;
+                        bFind = true;
+                        break;
+                    }
+                }
+                mMutex.unlock();
+
+                if(bFind)
+                {
+
+                        if(nNeedCheckSpace <= 0)
+                        {
+ //                           std::cout<<"check space."<<std::endl;
+                            nNeedCheckSpace = 1000;
+                            int nSpace = get_path_availspace(strhomepath);
+
+ //                           std::cout<<"hard space is "<<nSpace<<" MB."<<std::endl;
+                            if(nSpace<1000)
+                            {
+                                std::cout<<"Hard Disk No space to save std log."<<std::endl;
+                                bHaveHDDSpace = false;
+                            }
+                        }
+                        nNeedCheckSpace--;
+                        if(bHaveHDDSpace)
+                        {
+                            QString strlog;
+                            strlog = QDateTime::currentDateTime().toString("(yyyy/MM/dd hh:mm:ss:zzz")
+                                    + " | " + strappname.data() + " "+ strarg.data() + ")"
+                                    +xvectorerrout[i].mba.data();
+                            WriteLog(strlog.toLatin1().data());
+                        }
+
+                }
+                else
+                {
+                    std::cout<<"not found a std out 's process."<<std::endl;
+                }
+            }
+
+        }
+    }
+
+    std::cout<<"threaderrout complete."<<std::endl;
+}
+
 void ProgMon::threadstdout()
 {
 
@@ -753,7 +855,7 @@ void ProgMon::threadstdout()
                             int nSpace = get_path_availspace(strhomepath);
 
  //                           std::cout<<"hard space is "<<nSpace<<" MB."<<std::endl;
-                            if(nSpace<100)
+                            if(nSpace<1000)
                             {
                                 std::cout<<"Hard Disk No space to save std log."<<std::endl;
                                 bHaveHDDSpace = false;

src/tool/IVSysMan/progmon.h

@@ -106,14 +106,20 @@ public:
 
 private:
     void threadstdout();
+    void threaderrout();
 
     std::vector<stdoutunit> mvectorstdout;
     QMutex mMutex_stdout;
     bool mbstdoutrun = true;
 
+    std::vector<stdoutunit> mvectorerrout;
+    QMutex mMutex_errout;
+    bool mberroutrun = true;
+
     bool mbAllNoLog = true;
 
     std::thread * mpthread_stdout;
+    std::thread * mpthread_errout;
 
 private:
     inline void LogError(QProcess * proc,QByteArray & ba);

src/tool/IVSysMan/programviewunit.cpp

@@ -62,6 +62,7 @@ ProgramViewUnit::ProgramViewUnit(QGroupBox * pGroup,ProgUnit * pu, int x,int y)
     pswitch->setGeometry(nXPos,y,90,nHgt);
     nXPos = nXPos + 100;
     pswitch->setChecked(false);
+    if(pu->mbSavestdout)pswitch->setChecked(true);
     mpLogStd = pswitch;
 
     mPU = pu;