system.h

Go to the documentation of this file.

// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2014 The Bitcoin developers
// Copyright (c) 2014-2015 The Dash developers
// Copyright (c) 2015-2022 The PIVX Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or https://www.opensource.org/licenses/mit-license.php.
 
#ifndef PIVX_UTIL_SYSTEM_H
#define PIVX_UTIL_SYSTEM_H
 
#if defined(HAVE_CONFIG_H)
#include "config/pivx-config.h"
#endif
 
#include "fs.h"
#include "logging.h"
#include "compat.h"
#include "optional.h"
#include "sync.h"
#include "tinyformat.h"
#include "utiltime.h"
#include "util/threadnames.h"
 
#include <atomic>
#include <exception>
#include <map>
#include <memory>
#include <set>
#include <stdint.h>
#include <string>
#include <unordered_set>
#include <utility>
#include <vector>
 
#include <boost/signals2/signal.hpp>
#include <boost/thread/condition_variable.hpp> // for boost::thread_interrupted
 
class CTranslationInterface
{
public:
    boost::signals2::signal<std::string (const char* psz)> Translate;
};
 
extern const char * const PIVX_CONF_FILENAME;
extern const char * const PIVX_PID_FILENAME;
extern const char * const PIVX_MASTERNODE_CONF_FILENAME;
extern const char * const DEFAULT_DEBUGLOGFILE;
 
//PIVX only features
 
extern std::atomic<bool> fMasterNode;
 
extern CTranslationInterface translationInterface;
 
inline std::string _(const char* psz)
{
    // todo: this Optional is needed for now. Will get removed moving forward
    Optional<std::string> rv = translationInterface.Translate(psz);
    return rv ? (*rv) : psz;
}
 
 
void SetupEnvironment();
bool SetupNetworking();
 
template<typename... Args>
bool error(const char* fmt, const Args&... args)
{
    LogPrintf("ERROR: %s\n", tfm::format(fmt, args...));
    return false;
}
 
void PrintExceptionContinue(const std::exception* pex, const char* pszThread);
bool FileCommit(FILE* file);
bool TruncateFile(FILE* file, unsigned int length);
int RaiseFileDescriptorLimit(int nMinFD);
void AllocateFileRange(FILE* file, unsigned int offset, unsigned int length);
bool CheckDiskSpace(const fs::path& dir, uint64_t additional_bytes = 0);
bool RenameOver(fs::path src, fs::path dest);
bool LockDirectory(const fs::path& directory, const std::string& lockfile_name, bool probe_only=false);
bool DirIsWritable(const fs::path& directory);
 
void ReleaseDirectoryLocks();
 
bool TryCreateDirectories(const fs::path& p);
fs::path GetDefaultDataDir();
// The blocks directory is always net specific.
const fs::path &GetBlocksDir();
const fs::path &GetDataDir(bool fNetSpecific = true);
// Return true if -datadir option points to a valid directory or is not specified.
bool CheckDataDirOption();
// Sapling network dir
const fs::path &ZC_GetParamsDir();
// Init sapling library
void initZKSNARKS();
void ClearDatadirCache();
fs::path GetConfigFile(const std::string& confPath);
fs::path GetMasternodeConfigFile();
#ifdef WIN32
fs::path GetSpecialFolderPath(int nFolder, bool fCreate = true);
#endif
 
void runCommand(std::string strCommand);
 
inline bool IsSwitchChar(char c)
{
#ifdef WIN32
    return c == '-' || c == '/';
#else
    return c == '-';
#endif
}
 
class ArgsManager
{
protected:
    friend class ArgsManagerHelper;
 
    mutable RecursiveMutex cs_args;
    std::map<std::string, std::vector<std::string>> m_override_args;
    std::map<std::string, std::vector<std::string>> m_config_args;
    std::string m_network;
    std::set<std::string> m_network_only_args;
 
    void ReadConfigStream(std::istream& stream);
 
public:
    ArgsManager();
 
    void SelectConfigNetwork(const std::string& network);
 
    void ParseParameters(int argc, const char* const argv[]);
    void ReadConfigFile(const std::string& confPath);
 
    void WarnForSectionOnlyArgs();
 
    std::vector<std::string> GetArgs(const std::string& strArg) const;
 
    bool IsArgSet(const std::string& strArg) const;
 
    bool IsArgNegated(const std::string& strArg) const;
 
    std::string GetArg(const std::string& strArg, const std::string& strDefault) const;
 
    int64_t GetArg(const std::string& strArg, int64_t nDefault) const;
 
    bool GetBoolArg(const std::string& strArg, bool fDefault) const;
 
    bool SoftSetArg(const std::string& strArg, const std::string& strValue);
 
    bool SoftSetBoolArg(const std::string& strArg, bool fValue);
 
    // Forces an arg setting. Called by SoftSetArg() if the arg hasn't already
    // been set. Also called directly in testing.
    void ForceSetArg(const std::string& strArg, const std::string& strValue);
 
    std::string GetChainName() const;
};
 
extern ArgsManager gArgs;
 
std::string HelpMessageGroup(const std::string& message);
 
std::string HelpMessageOpt(const std::string& option, const std::string& message);
 
int GetNumCores();
 
void SetThreadPriority(int nPriority);
 
template <typename Callable>
void TraceThread(const std::string name, Callable func)
{
    std::string s = "pivx-" + name;
    util::ThreadRename(s.c_str());
    try {
        LogPrintf("%s thread start\n", name);
        func();
        LogPrintf("%s thread exit\n", name);
    } catch (boost::thread_interrupted) {
        LogPrintf("%s thread interrupt\n", name);
        throw;
    } catch (std::exception& e) {
        PrintExceptionContinue(&e, name.c_str());
        throw;
    } catch (...) {
        PrintExceptionContinue(nullptr, name.c_str());
        throw;
    }
}
 
fs::path AbsPathForConfigVal(const fs::path& path, bool net_specific = true);
 
int ScheduleBatchPriority(void);
 
namespace util {
 
#ifdef WIN32
class WinCmdLineArgs
{
public:
    WinCmdLineArgs();
    ~WinCmdLineArgs();
    std::pair<int, char**> get();
 
private:
    int argc;
    char** argv;
    std::vector<std::string> args;
};
#endif
 
} // namespace util
 
#endif // PIVX_UTIL_SYSTEM_H