bak

w1146869587

2021-11-09 337adce3b32612903dce4b963c7db6c8ba0202a4

bak

 bak/mb_watch_user.db

Binary files differ

 bak/mbwatch.txt

@@ -2,7 +2,7 @@
    CN_S_LOGIN       VARCHAR (128) NOT NULL,
    CN_S_SERVER_ID   VARCHAR (128) NOT NULL,
    CN_S_BACKUP_DIR  VARCHAR (512) NOT NULL,
    CN_S_SERVER_PATH VARCHAR (512) NOT NULL,
    CN_S_SERVER_PATH VARCHAR (512),
    CN_S_ISLOGIN     CHAR (2)      DEFAULT N,
    PRIMARY KEY (
        CN_S_LOGIN,

 mbwatch/efsw.pri

New file
@@ -0,0 +1,10 @@
INCLUDEPATH += $$PWD/../efsw

CONFIG(debug, debug|release) {
    LIBS += -L$$PWD/../debug -lefsw
} else {
    LIBS += -L$$PWD/../release -lefsw
}




 mbwatch/mbtasklog.cpp

New file
@@ -0,0 +1,23 @@
#include "mbtasklog.h"
#include <QMutex>

CMBTaskLog::CMBTaskLog()
{

}

CMBTaskLog::~CMBTaskLog()
{
}


void CMBTaskLog::run()
{

}







 mbwatch/mbtasklog.h

New file
@@ -0,0 +1,21 @@
#ifndef MBTASKLOG_H
#define MBTASKLOG_H

#include <QRunnable>
#include <QWaitCondition>
#include <QMutex>

/************************************************************************/
/*   日志任务，用来记录备份目录下的文件变化                                    */
/************************************************************************/
class CMBTaskLog
        : public QRunnable
{
public:
    CMBTaskLog();
    ~CMBTaskLog();
public:
    virtual          void run();
};

#endif // MBTASKLOG_H

 mbwatch/mbtaskmgr.cpp

New file
@@ -0,0 +1,39 @@
#include "mbtaskmgr.h"

CMBTaskMgr::CMBTaskMgr()
{
    //线程池最多1个线程
    m_threadPool.setMaxThreadCount(1);
}

CMBTaskMgr::~CMBTaskMgr()
{

}

void CMBTaskMgr::stopThread()
{
    m_threadPool.waitForDone(100); // 100毫秒
}

void CMBTaskMgr::logTask(QString login, QString svrID, QString backupDir, QString svrPath)
{

}


//void CMBTaskMgr::loginOrgTask(QString ip, int nPort, QString session)
//{
//    CMBLoginOrgTask *pTask = new CMBLoginOrgTask();
//    pTask->setMDWare(m_pMDWare);
//    pTask->setUserInfo(m_login,m_loginName);
//    pTask->setSvrInfo(ip, nPort, session);
//    pTask->setAutoDelete(true);

//    m_threadPool.start(pTask);
//}






 mbwatch/mbtaskmgr.h

New file
@@ -0,0 +1,26 @@
#ifndef MBTASKMGR_H
#define MBTASKMGR_H

#include <QThreadPool>


/************************************************************************/
/*  任务管理器                                                            */
/************************************************************************/
class CMBTaskMgr
{
public:
    CMBTaskMgr();
    ~CMBTaskMgr();
private:
    QThreadPool     m_threadPool;
public:
    void             stopThread();
public:
    void             logTask( QString login, QString svrID,
                               QString backupDir, QString svrPath );
};



#endif // MBTASKMGR_H

 mbwatch/mbwatch.pro

@@ -1,5 +1,6 @@
QT -= gui
QT += network
QT += sql

CONFIG += c++11 console
CONFIG -= app_bundle
@@ -15,6 +16,8 @@
        main.cpp \
        mbcommfunc.cpp \
        mbfileutil.cpp \
        mbtasklog.cpp \
        mbtaskmgr.cpp \
        mbwatchapp.cpp \
        mbwatchconst.cpp \
        mbwatchfile.cpp \
@@ -24,18 +27,11 @@
        mbwatchuserdb.cpp \
        mbwatchusermgr.cpp

# Default rules for deployment.
qnx: target.path = /tmp/$${TARGET}/bin
else: unix:!android: target.path = /opt/$${TARGET}/bin
!isEmpty(target.path): INSTALLS += target

# cfg
include(mbwatch.pri)
include(qtservice/qtservice.pri)

HEADERS += \
    mbcommfunc.h \
    mbfileutil.h \
    mbtasklog.h \
    mbtaskmgr.h \
    mbwatchapp.h \
    mbwatchconst.h \
    mbwatchfile.h \
@@ -45,3 +41,14 @@
    mbwatchuserdb.h \
    mbwatchusermgr.h

# Default rules for deployment.
qnx: target.path = /tmp/$${TARGET}/bin
else: unix:!android: target.path = /opt/$${TARGET}/bin
!isEmpty(target.path): INSTALLS += target

# cfg
include(mbwatch.pri)
include(qtservice/qtservice.pri)
include(efsw.pri)



 mbwatch/mbwatchmain.cpp

@@ -49,7 +49,7 @@

void CMBWatchMain::stop()
{

    m_pMgr->stop();
}

void CMBWatchMain::pause()
@@ -78,10 +78,31 @@
        std::cout << errInfo.toStdString() << std::endl;
        return ;
    }
    // 比较 日志，写
    QString login, svrID, backupDir, svrPath;

    CMBWatchUserVector::iterator    it;
    CMBWatchUser *pUser = NULL;

    CMBWatchUserVector tmpVector;
    m_pMgr->getUserMgr()->getVector(tmpVector);
    for( it = tmpVector.begin();it != tmpVector.end();it++ )
    {
        pUser = *it;

        login     = pUser->getLogin();
        svrID     = pUser->getSvrID();
        backupDir = pUser->getBackupDir();
        svrPath   = pUser->getSvrPath();

        m_pMgr->getTaskMgr()->logTask(login, svrID, backupDir, svrPath);
    }

}

void CMBWatchMain::onSigFileChange(QString fileName)
{

    //
}


 mbwatch/mbwatchmgr.cpp

@@ -3,7 +3,11 @@
CMBWatchMgr::CMBWatchMgr()
{
    m_pConst     = new CMBWatchConst();
    m_pTaskMgr   = new CMBTaskMgr();

    m_pUserMgr   = new CMBWatchUserMgr();
    m_pUserDb    = new CMBWatchUserDb();
    m_pUserDb->setUserMgr(m_pUserMgr);
}

CMBWatchMgr::~CMBWatchMgr()
@@ -16,7 +20,14 @@
        delete m_pUserDb;
        m_pUserDb = NULL;
    }

    if(m_pUserMgr){
        delete m_pUserMgr;
        m_pUserMgr = NULL;
    }
    if( m_pTaskMgr ){
        delete m_pTaskMgr;
        m_pTaskMgr = NULL;
    }
}

CMBWatchConst *CMBWatchMgr::getConst()
@@ -24,12 +35,28 @@
    return m_pConst;
}

CMBWatchUserMgr *CMBWatchMgr::getUserMgr()
{
    return m_pUserMgr;
}

CMBTaskMgr *CMBWatchMgr::getTaskMgr()
{
    return m_pTaskMgr;
}

bool CMBWatchMgr::init(QString &errInfo)
{
     QString watchUserDB = m_pConst->getWatchUserDB();
     if(!m_pUserDb->init(watchUserDB,errInfo))
         return false;
    QString watchUserDB = m_pConst->getWatchUserDB();
    if(!m_pUserDb->init(watchUserDB,errInfo))
        return false;

    return true;
}

     return true;
bool CMBWatchMgr::stop()
{
    m_pTaskMgr->stopThread();

    return true;
}

 mbwatch/mbwatchmgr.h

@@ -2,6 +2,7 @@
#define MBWATCHMGR_H
#include "mbwatchconst.h"
#include "mbwatchuserdb.h"
#include "mbtaskmgr.h"

class CMBWatchMgr
{
@@ -9,13 +10,20 @@
    CMBWatchMgr();
    ~CMBWatchMgr();
private:
    CMBWatchConst  *m_pConst;
    CMBWatchConst   *m_pConst;
private:
    CMBWatchUserDb *m_pUserDb;
    CMBWatchUserDb   *m_pUserDb;
    CMBWatchUserMgr  *m_pUserMgr;
private:
    CMBTaskMgr       *m_pTaskMgr;
public:
    CMBWatchConst *getConst();
    CMBWatchConst    *getConst();
    CMBWatchUserMgr  *getUserMgr();
    CMBTaskMgr       *getTaskMgr();
public:
    bool           init(QString &errInfo);
public:
    bool           stop();
};

#endif // MBWATCHMGR_H

 mbwatch/mbwatchuserdb.cpp

@@ -1,22 +1,224 @@
#include "mbwatchuserdb.h"
#include <QSqlQuery>
#include <QSqlError>
#include <QRandomGenerator>
#include <QDebug>

CMBWatchUserDb::CMBWatchUserDb()
{
    m_pMgr = new CMBWatchUserMgr();
    m_pMgr      = NULL;
    m_tableName = "TN_WATCH_USER";
}

CMBWatchUserDb::~CMBWatchUserDb()
{
    if( m_pMgr ){
        delete m_pMgr;
        m_pMgr = NULL;

}

void CMBWatchUserDb::setUserMgr(CMBWatchUserMgr *pMgr)
{
    m_pMgr = pMgr;
}

QSqlDatabase CMBWatchUserDb::openDataBase()
{
    quint32 value = QRandomGenerator::global()->generate();
    QSqlDatabase db;
    if ( true == QSqlDatabase::contains(QString::number(value)))
    {
        db = QSqlDatabase::database(QString::number(value));
    }
    else
    {
        db = QSqlDatabase::addDatabase("QSQLITE", QString::number(value));
        db.setDatabaseName(m_path);
    }

    if (false == db.open())
    {
        qDebug() << db.lastError().text();
    }
    return db;
}

void CMBWatchUserDb::closeDataBase(QString connectionName)
{
    if( QSqlDatabase::contains(connectionName) ){
       QSqlDatabase::removeDatabase(connectionName);
    }
}

bool CMBWatchUserDb::execSql(QString sql, QString &errInfo)
{
    QMutexLocker locker(&m_mutex);

    QString connectionName;
    {
        QSqlDatabase db = openDataBase();
        connectionName = db.connectionName();

        QSqlQuery query(db);
        query.prepare(sql);

        if( !query.exec()){
            errInfo = query.lastError().text();
            return false;
        }
        query.clear();
    }

    closeDataBase(connectionName);

    return true;
}

bool CMBWatchUserDb::execSql(QSqlDatabase &db, QString sql, QString &errInfo)
{
    QSqlQuery query(db);
    query.prepare(sql);

    if( !query.exec()){
        errInfo = query.lastError().text();
        return false;
    }
    query.clear();

    return true;
}

bool CMBWatchUserDb::getTmpFiledSql(QString sql, QString &tmpValue, QString &errInfo)
{
    QMutexLocker locker(&m_mutex);

    QString connectionName;
    {
        QSqlDatabase db = openDataBase();
        connectionName = db.connectionName();

        QSqlQuery query(db);
        query.prepare(sql);

        if( !query.exec()){
            errInfo = query.lastError().text();
            return false;
        }
        while(query.next())
        {
            tmpValue = query.value("TmpFiled").toString();
        }

        query.clear();
    }

    closeDataBase(connectionName);

    return true;
}

bool CMBWatchUserDb::exsitSql(QString sql, bool &bExsit, QString &errInfo)
{
    QMutexLocker locker(&m_mutex);

    bExsit = false;

    QString connectionName;
    {
        QSqlDatabase db = openDataBase();
        connectionName = db.connectionName();

        QSqlQuery query(db);
        query.prepare(sql);

        if( !query.exec()){
            errInfo = query.lastError().text();
            return false;
        }
        // 获取大小
        int initialPos = query.at();
        int nCount = 0;
        if (query.last())
            nCount = query.at() + 1;
        else
            nCount = 0;
        query.seek(initialPos);
        // end 获取大小
        if( nCount >= 1 ){
            bExsit = true;
        }

        query.clear();
    }

    closeDataBase(connectionName);
    return true;
}


bool CMBWatchUserDb::init(QString path,QString &errInfo)
{
    m_path = path;

    m_pMgr->removeAll();

    if( !queryDB(errInfo) )
        return false;

    return true;
}

bool CMBWatchUserDb::loadDB(QSqlQuery &query)
{
    while(query.next())
    {
        QString login     = query.value("CN_S_LOGIN").toString();
        QString svrID     = query.value("CN_S_SERVER_ID").toString();
        QString backupDir = query.value("CN_S_BACKUP_DIR").toString();
        QString svrPath   = query.value("CN_S_SERVER_PATH").toString();
        QString isLogin   = query.value("CN_S_ISLOGIN").toString();

        CMBWatchUser *pUser = new CMBWatchUser();
        pUser->setLogin(login);
        pUser->setSvrID(svrID);
        pUser->setBackupDir(backupDir);
        pUser->setSvrPath(svrPath);
        pUser->setIsLogin(isLogin);

        if( !m_pMgr->add(pUser) ){
            delete pUser;
            pUser = NULL;
        }
    }

    return true;
}

bool CMBWatchUserDb::queryDB(QString &errInfo)
{
    QMutexLocker locker(&m_mutex);

    QString connectionName,sql;

    sql = QString("select * from %1 where CN_S_ISLOGIN='Y'").arg(m_tableName);

    {
        QSqlDatabase db = openDataBase();
        connectionName = db.connectionName();

        QSqlQuery query(db);
        query.prepare(sql);

        if( !query.exec()){
            errInfo = query.lastError().text();
            return false;
        }

        if(!loadDB(query))
            return false;

        query.clear();
    }

    closeDataBase(connectionName);

    return true;
}

 mbwatch/mbwatchuserdb.h

@@ -2,6 +2,7 @@
#define MBWATCHUSERDB_H
#include "mbwatchusermgr.h"
#include <QObject>
#include <QSqlDatabase>

class CMBWatchUserDb
{
@@ -9,9 +10,28 @@
    CMBWatchUserDb();
    ~CMBWatchUserDb();
private:
    QMutex           m_mutex;
private:
    CMBWatchUserMgr *m_pMgr;
private:
    QString          m_path;
    QString          m_tableName;
public:
    bool init(QString path,QString &errInfo);
    void             setUserMgr(CMBWatchUserMgr *pMgr);
private:
    QSqlDatabase openDataBase();
    void         closeDataBase(QString connectionName);
private:
    bool         execSql( QString sql,QString &errInfo );  // 执行sql
    bool         execSql(QSqlDatabase &db,QString sql,QString &errInfo );  // 执行sql
    bool         getTmpFiledSql( QString sql,QString &tmpValue,QString &errInfo );  // 获取tmp字段的值
    bool         exsitSql( QString sql,bool &bExsit,QString &errInfo );
public:
    bool         init(QString path,QString &errInfo);
private:
    bool         loadDB(QSqlQuery &query);
public:
    bool         queryDB(QString &errInfo);
};

#endif // MBWATCHUSERDB_H

 mbwatch/mbwatchusermgr.cpp

@@ -2,16 +2,18 @@

CMBWatchUserMgr::CMBWatchUserMgr()
{

    removeAll();
}

CMBWatchUserMgr::~CMBWatchUserMgr()
{

    removeAll();
}

bool CMBWatchUserMgr::add(CMBWatchUser *pUser)
{
    QMutexLocker locker(&m_mutex);

    if( NULL == pUser )
        return false;

@@ -28,6 +30,8 @@

CMBWatchUser *CMBWatchUserMgr::get(QString login, QString svrID)
{
    QMutexLocker locker(&m_mutex);

    login = login.trimmed();
    svrID = svrID.trimmed();
    if( login.isEmpty() || svrID.isEmpty() )
@@ -52,6 +56,8 @@

bool CMBWatchUserMgr::removeAll()
{
    QMutexLocker locker(&m_mutex);

    qDeleteAll(m_vector.begin(),m_vector.end());

    m_vector.clear();
@@ -61,9 +67,17 @@

bool CMBWatchUserMgr::is(QString login, QString svrID)
{
    QMutexLocker locker(&m_mutex);

    CMBWatchUser *pUser = get(login, svrID);
    if( NULL == pUser )
        return false;

    return true;
}

void CMBWatchUserMgr::getVector(CMBWatchUserVector &vector)
{
    vector.clear();
    vector = m_vector;
}

 mbwatch/mbwatchusermgr.h

@@ -1,6 +1,7 @@
#ifndef MBWATCHUSERMGR_H
#define MBWATCHUSERMGR_H
#include "mbwatchuser.h"
#include <QMutex>

class CMBWatchUserMgr
{
@@ -9,11 +10,14 @@
    ~CMBWatchUserMgr();
private:
    CMBWatchUserVector m_vector;
private:
     QMutex   m_mutex;
public:
    bool                add(CMBWatchUser *pUser );        // 添加数据
    CMBWatchUser       *get(QString login,QString svrID);
    bool                removeAll();                    // 移除
    bool                is(QString login,QString svrID);
    void                getVector(CMBWatchUserVector &vector);
};

#endif // MBWATCHUSERMGR_H