SystemTools.hxx

Go to the documentation of this file.

//
// Created by Zhiping Jiang on 1/26/21.
//
 
#ifndef SYSTEM_TOOLS_HXX
#define SYSTEM_TOOLS_HXX
 
#include <chrono>
#include <optional>
#include <iostream>
#include <fstream>
#include <vector>
#include <array>
#include <random>
#include <condition_variable>
#include <filesystem>
#include <type_traits>
#if !(defined(_WIN32) || defined(WIN32))
#include <net/if.h>
#include <arpa/inet.h>
#endif
#include "BoostHeaders.hxx"
#include "LoggingService.hxx"
#include "TimeTools.hxx"
 
using namespace std::chrono_literals;
namespace fs = std::filesystem;
 
namespace SystemTools {
    namespace Shared {
        uint32_t getUID();
 
        uint32_t getPID();
 
        uint32_t getParentPID();
 
        std::string getCurrentUserName();
 
        std::string getFilePathForPID(uint32_t pid);
 
        std::string getCurrentProcessFullPath();
 
        std::string getCurrentCommandLineContent();
 
        std::string getProcessName(uint32_t pid);
 
        std::string invokeCommandLineCommand(const std::string& cmdString, int* returnStatus = nullptr);
 
        std::string getKernelVersion();
 
        uint8_t getCPUNumber();
 
        uint64_t getSystemFreeMemory();
 
        void openURLWithDefaultBrowser(const std::string& url);
    }
 
    namespace File {
        std::string getHomeDirectory();
 
        bool checkCommandExists(const std::string& command);
 
        std::vector<struct timespec> getAccessChangeModifyTimeOfFile(const std::string& file);
 
        bool touchFile(const std::string& file, std::optional<struct timespec> targetTimeOrNow);
 
        std::string getFileOwner(const std::string& filePath);
 
        std::vector<uint8_t> readContentFromFile(const std::string& file);
 
        std::string readContentFromFileAsString(const std::string& file);
 
        std::vector<std::string> readContentFromFileLineByLine(const std::string& filePath);
 
        void writeContent2File(const std::string& file, const uint8_t* buffer, size_t bufferLength);
 
        void writeContent2File(const std::string& file, const std::string& content);
 
        bool removeFile(const std::string& filePath);
 
        std::vector<fs::path> listFilesWithExtension(fs::path folderPath, std::string prefix = "", std::string surfix = "");
 
        std::vector<fs::path> listFilesRecursivelyWithExtension(fs::path folderPath, std::string prefix = "", std::string surfix = "");
 
        template<typename ParseType>
        ParseType readValueFromFilePath(const std::string& path) {
            std::fstream fin(path, std::ios::in);
            std::string line;
            std::getline(fin, line);
            fin.close();
            if (line.empty()) {
                throw std::invalid_argument(fmt::sprintf("The result of path \"%s\" is empty! \n", path));
            }
 
            if constexpr (std::is_same_v<ParseType, std::string>) {
                return line;
            } else {
                double valueD = std::stod(line); // boost::lexical_cast cannot recognize '0x3' style
                return static_cast<ParseType>(valueD);
            }
        }
 
        template<typename ParseType>
        int writeValue2FilePath(const std::string& path, const ParseType& value, const std::string& formatStr = "{}") {
            auto valueString = fmt::format(fmt::runtime(formatStr), value);
            std::fstream fout(path, std::ios::out);
            try {
                fout << valueString;
                fout.close();
                return 0;
            } catch (const std::exception&) {
                throw std::runtime_error(fmt::format("Cannot write value {} to path {}.", value, path));
            }
        }
    };
 
    namespace Net {
        bool hasInternetConnection();
 
        std::tuple<bool, std::string, std::optional<TimePoint_System_Millisecond>> checkInternetConnectionAndGetGMTTime(bool forceRefresh = false);
 
        std::vector<uint8_t> curlDownloadNoBody(const std::string& url, uint32_t timeout_ms = 0, long* httpResponseCode = nullptr);
 
        std::vector<uint8_t> curlDownload(const std::string& url, uint32_t timeout_ms = 0, long* httpResponseCode = nullptr);
 
        std::string curlDownloadContentAsString(const std::string& url, uint32_t timeout_ms = 0, long* httpResponseCode = nullptr);
 
        int udpSendData(const std::string& sessionName, const uint8_t* data, uint32_t bufferLength, const std::string& targetIP, uint16_t targetPoint, std::optional<uint16_t> sourcePort = std::nullopt);
    }
 
    namespace Math {
        template<typename DataType>
        DataType uniformRandomNumberWithinRange(DataType min, DataType max) {
            static std::random_device r;
            static std::default_random_engine randomEngine(r());
            static std::uniform_int_distribution<DataType> randomGenerator(min, max);
            return randomGenerator(randomEngine);
        }
    }
 
    namespace Persistence {
        std::string boostPropertyTree2JSON(const pt::ptree& tree, bool prettyOutput = true);
 
        pt::ptree jSON2BoostPropertyTree(const std::string& jsonContent);
 
        std::string boostPropertyTree2INI(const pt::ptree& tree, bool prettyOutput = true);
 
        pt::ptree INI2BoostPropertyTree(const std::string& iniContent);
    }
 
    namespace Thread {
        std::string getThreadName(uint64_t threadId);
 
        void setThreadName(uint64_t threadId, const std::string& threadName);
 
        std::string getCurrentThreadName();
 
        void setName4CurrentThread(const std::string& threadName);
 
        uint64_t getCurrentThreadId();
    }
 
    namespace Misc {
        std::string getCPUGovernor();
 
        bool isPackageInstalled(const std::string& packageName);
    }
}
 
#endif //SYSTEM_TOOLS_HXX