status.h

Go to the documentation of this file.

#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <fstream>
#include <iostream>
#include <string>
#include <assert.h>
#include <sstream>
#include <vector>
#include <map>
#include <boost/lexical_cast.hpp>
#include <boost/system/error_code.hpp>
#ifdef TESTING
#include "gtest/gtest.h"
#endif

namespace dpyStatus{


enum Result
{
    OK = 1, 
    ERROR = 2, 
    IN_PROCESS = 3, 
    UPDATED = 4, 
    BACKUP = 5 
};

}

class Status
{
private:
    static Status *instance;

    std::string statusFilePath;

    int _usedRFS = 1;

    int _activeRFS = 1;

    std::map<int, std::string> rfs_status;

    int _usedKernel = 1;

    int _activeKernel = 1;

    std::map<int, std::string> kernel_status;

    std::map<std::string, dpyStatus::Result> translationStatuMap;

    bool processUsedKernel(std::string command);
    bool processUsedRfs(std::string command);

    void fixStatusFile(std::string path = "");
    bool writeDefaultStatus(boost::system::error_code& ec, std::string path = "");
    
protected:
    explicit Status();

public:
    static Status *getInstance();
    bool init(boost::system::error_code& ec, std::string path, std::string cmdline="cat /proc/cmdline");
    bool readStatus(boost::system::error_code& ec, std::string path = "");
    bool writeStatus(boost::system::error_code& ec, std::string path = "");

    //Status
    dpyStatus::Result curRfsStatus();
    dpyStatus::Result altRfsStatus();
    dpyStatus::Result curKernelStatus();
    dpyStatus::Result altKernelStatus();

    //Update OK
    void setCurRFSStatus(dpyStatus::Result status);
    void setAltRFSStatus(dpyStatus::Result status);

    void setCurKernelStatus(dpyStatus::Result status);
    void setAltKernelStatus(dpyStatus::Result status);

    void repairActiveRFS();
    void repairActiveKernel();

    void changeActiveRFS();
    void changeActiveKernel();

    //Getters
    int usedRFS() const
    {
        return _usedRFS;
    }

    int activeRFS() const
    {
        return _activeRFS;
    }

    int alternativeRFS()
    {
        if (_usedRFS == 1) {
            return 2;
        } else {
            return 1;
        }
    }

    int usedKernel() const
    {
        return _usedKernel;
    }

    int activeKernel() const
    {
        return _activeKernel;
    }

    int alternativeKernel()
    {
        if (_usedKernel == 1) {
            return 2;
        } else {
            return 1;
        }
    }

#ifdef TESTING
public:
    FRIEND_TEST(Status_test, readStatus_File_does_not_exist);
    FRIEND_TEST(Status_test, writeDefaultStatusOK);
    FRIEND_TEST(Status_test, writeStatusError);
    FRIEND_TEST(Status_test,readStatusParseError);
    FRIEND_TEST(Status_test,readStatusValueError);
    FRIEND_TEST(Status_test,readStatusKeyError);
    FRIEND_TEST(Status_test,readStatusWrongValueKernel);
    FRIEND_TEST(Status_test,readStatusWrongValueRfs);
    FRIEND_TEST(Status_test,processUsedKernel1Correct);
    FRIEND_TEST(Status_test,processUsedRfs1Correct);
    FRIEND_TEST(Status_test,processUsedRfs2Correct);
    FRIEND_TEST(Status_test,processUsedKernel2Correct);
    FRIEND_TEST(Status_test,changeStatus);
    FRIEND_TEST(Status_test,currentDefaultStatus);
    FRIEND_TEST(Status_test,translationMapCreation);
    FRIEND_TEST(Status_test,StatusInitParseError);
    FRIEND_TEST(Status_test,StatusInitFileDoesNotExit);
    FRIEND_TEST(Status_test,StatusInitCorrect);
    FRIEND_TEST(Status_test,processUsedRfsError);
    FRIEND_TEST(Status_test,processUsedKernelError);
    FRIEND_TEST(Status_test,changeActiveKernelCorrect);
    FRIEND_TEST(Status_test,changeActiveRfsCorrect);
    FRIEND_TEST(Status_test,repairActiveRfsCorrect);
    FRIEND_TEST(Status_test,repairActiveKernelCorrect);   
#endif
};