modularization/src/driver/driver_ota_server/otaserver.cpp

#include "otaserver.h"
#include "mainwindow.h"

extern MainWindow * gw;

void OTAServiceImpl::log(char *str)
{
    std::cout<<str<<std::endl;
    std::string strlog = str;
    gw->updatelog(strlog);
}

Status OTAServiceImpl::query(grpc::ServerContext *context, const iv::ota::queryreq *request, iv::ota::queryReply *response)
{
    (void)context;
    char strlog[1000];
    snprintf(strlog,1000,"%s VehicleType:%s Version:%s VIN:%s query.",QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss:zzz").toLatin1().data(),
             request->strvehicletype().data(),request->strversion().data(),
             request->strvin().data());
    log(strlog);
    std::vector<iv::vehiclefile> xvectorvf;
    mMutexVF.lock();
    xvectorvf = mvectorvf;

    bool bupdate = false;
    unsigned int i;
    unsigned int index = 0;
    for(i=0;i<xvectorvf.size();i++)
    {
        if(xvectorvf[i].mstrVehicleType == request->strvehicletype())
        {
            if(request->strversion() == xvectorvf[i].mstrVersion)
            {
                snprintf(strlog,1000,"%s VehicleType:%s Version:%s VIN:%s Version is newest.",QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss:zzz").toLatin1().data(),
                         request->strvehicletype().data(),request->strversion().data(),
                         request->strvin().data());
                log(strlog);
            }
            else
            {
                bupdate = true;
                index = i;
            }
            break;
        }
    }
    response->set_bupdate(bupdate);
    if(bupdate)
    {
        response->set_strmd5(xvectorvf[index].mstrmd5);
        response->set_nfilesize(xvectorvf[index].mnFileSize);
        response->set_strversion(xvectorvf[index].mstrVersion);
        snprintf(strlog,1000,"%s VehicleType:%s Version:%s VIN:%s Set Need Update.",QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss:zzz").toLatin1().data(),
                 request->strvehicletype().data(),request->strversion().data(),
                 request->strvin().data());
        log(strlog);
    }

    mMutexVF.unlock();

//       std::cout<<"vehicle type:"<<request->strvehicletype()<<" version:"<<request->strversion()<<" VIN:"<<request->strvin()<<std::endl;
    return Status::OK;
}

Status OTAServiceImpl::downfile(grpc::ServerContext *context, const iv::ota::Filereq *request, iv::ota::FileReply *response)
{
    (void)context;
    char strlog[1000];
    snprintf(strlog,1000,"%s VehicleType:%s Version:%s VIN:%s request download file.Pos:%ld PacSize:%ld",QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss:zzz").toLatin1().data(),
             request->strvehicletype().data(),request->strversion().data(),
             request->strvin().data(),request->npos(),request->nsize());
    log(strlog);
    std::vector<iv::vehiclefile> xvectorvf;
    mMutexVF.lock();
    xvectorvf = mvectorvf;

    bool bupdate = false;
    unsigned int i;
    unsigned int index = 0;
    for(i=0;i<xvectorvf.size();i++)
    {
        if(xvectorvf[i].mstrVehicleType == request->strvehicletype())
        {
            index = i;
            bupdate = true;
            break;
        }
    }
    if(request->npos()<0 ||(request->npos()>= mvectorbadata[index].size()))
    {
        std::cout<<"nPos error."<<std::endl;
        bupdate = false;
    }
    response->set_bupdate(bupdate);
    if(bupdate)
    {

        response->set_strmd5(xvectorvf[index].mstrmd5);
        response->set_nfilesize(xvectorvf[index].mnFileSize);

        int nsize = request->nsize();
        if(mvectorbadata[index].size()<(nsize+request->npos()))nsize = mvectorbadata[index].size() - request->npos();
        if(mvectorbadata[index].size()<=(nsize+request->npos()))
        {
            response->set_blastpac(true);
        }
        else
        {
            response->set_blastpac(false);
        }
        response->set_nsize(nsize);
        response->set_xdata(mvectorbadata[index].data() + request->npos(),nsize);
        snprintf(strlog,1000,"%s VehicleType:%s Version:%s VIN:%s Transfer File.New version is %s. pos:%ld nsize:%ld",QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss:zzz").toLatin1().data(),
                 request->strvehicletype().data(),request->strversion().data(),
                 request->strvin().data(),mvectorvf[index].mstrVersion.data(),
                 request->npos(),response->nsize());
        log(strlog);
    }
    else
    {
        snprintf(strlog,1000,"%s VehicleType:%s Version:%s VIN:%s query file, but Not Found File.",QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss:zzz").toLatin1().data(),
                 request->strvehicletype().data(),request->strversion().data(),
                 request->strvin().data());
        log(strlog);
    }

    mMutexVF.unlock();

    return Status::OK;
}

void OTAServiceImpl::SetVehicleFile(std::vector<iv::vehiclefile> xvectorvf)
{
    mMutexVF.lock();
    unsigned int i;

    mvectorbadata.clear();
    mvectorvf.clear();
    for(i=0;i<xvectorvf.size();i++)
    {
        QFile xFile;
        xFile.setFileName(xvectorvf.at(i).mstrFilePath.data());
        if(xFile.open(QIODevice::ReadOnly))
        {
            QByteArray ba = xFile.readAll();
            if(ba.size() > 0)
            {
                mvectorbadata.push_back(ba);
                xvectorvf[i].mnFileSize = xFile.size();
                xvectorvf[i].mstrmd5 = getFileMD5(xvectorvf.at(i).mstrFilePath);
                mvectorvf.push_back(xvectorvf[i]);
            }
        }
        else
        {
            std::cout<<" File "<<xvectorvf[i].mstrFilePath<<" Can't open"<<std::endl;
        }
        xFile.close();
    }
    mMutexVF.unlock();
}


otaserver::otaserver()
{
    mpOTAService = new OTAServiceImpl();
}

void otaserver::run()
{
    std::string server_address("0.0.0.0:60051");
  //  OTAServiceImpl service;

    grpc::EnableDefaultHealthCheckService(true);
  //  grpc::reflection::InitProtoReflectionServerBuilderPlugin();
    ServerBuilder builder;
    // Listen on the given address without any authentication mechanism.
    builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());

    builder.SetMaxReceiveMessageSize(1000000000);
    builder.SetMaxSendMessageSize(1000000000);


  //  builder.SetMaxSendMessageSize(100000000);
    // Register "service" as the instance through which we'll communicate with
    // clients. In this case it corresponds to an *synchronous* service.
    builder.RegisterService(mpOTAService);
    // Finally assemble the server.
    std::unique_ptr<Server> server(builder.BuildAndStart());
    std::cout << "Server listening on " << server_address << std::endl;

    // Wait for the server to shutdown. Note that some other thread must be
    // responsible for shutting down the server for this call to ever return.
    server->Wait();
}

void otaserver::SetVehicleFile(std::vector<iv::vehiclefile> xvectorvf)
{
    mpOTAService->SetVehicleFile(xvectorvf);
}