version_check.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2006-2026, Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2026, Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <sharg/std/charconv>
#include <array>
#include <cassert>
#include <filesystem>
#include <fstream>
#include <future>
#include <iostream>
#include <optional>
#include <regex>
 
#include <sharg/auxiliary.hpp>
#include <sharg/detail/terminal.hpp>
 
namespace sharg::detail
{
 
// ------------------------------------------------------------------------------------------------------------------
// function call_server()
// ------------------------------------------------------------------------------------------------------------------
 
inline void call_server(std::string const & command, std::promise<bool> prom)
{
    // system call - http response is stored in a file '.config/seqan/{appname}_version'
    if (system(command.c_str()))
        prom.set_value(false);
    else
        prom.set_value(true);
}
 
// ------------------------------------------------------------------------------------------------------------------
// function quote_argument()
// ------------------------------------------------------------------------------------------------------------------
 
inline std::string quote_argument(std::string const & argument)
{
#if defined(_WIN32)
    // The argument is part of a PowerShell command, which escapes a single quote by doubling it.
    // Windows is not supported. If it ever is, this needs to be adapted: PowerShell also treats the typographic quotes
    // U+2018 to U+201B as single quotes, and cmd.exe, which runs the command, expands %VARIABLE% even within quotes.
    constexpr std::string_view escaped_quote{"''"};
#else
    // A POSIX shell cannot escape a single quote within single quotes: close the quotes, add an escaped quote, reopen.
    constexpr std::string_view escaped_quote{"'\\''"};
#endif
 
    std::string result{'\''};
 
    for (char const c : argument)
    {
        if (c == '\'')
            result.append(escaped_quote);
        else
            result.push_back(c);
    }
 
    result.push_back('\'');
    return result;
}
 
// ------------------------------------------------------------------------------------------------------------------
// version_checker
// ------------------------------------------------------------------------------------------------------------------
 
class version_checker
{
public:
    version_checker() = delete;
    version_checker(version_checker const &) = default;             
    version_checker & operator=(version_checker const &) = default; 
    version_checker(version_checker &&) = default;                  
    version_checker & operator=(version_checker &&) = default;      
    ~version_checker() = default;                                   
 
    version_checker(std::string name_, std::string const & version_, std::string const & app_url = std::string{}) :
        name{std::move(name_)}
    {
        assert(std::regex_match(name, std::regex{"^[a-zA-Z0-9_-]+$"})); // check on construction of the parser
 
        if (!app_url.empty())
        {
            message_app_update.pop_back(); // remove second newline
            message_app_update.append("[APP VERSION INFO] :: Visit " + app_url + " for updates.\n\n");
        }
 
#if defined(NDEBUG)
        timestamp_filename = cookie_path / (name + "_usr.timestamp");
#else
        timestamp_filename = cookie_path / (name + "_dev.timestamp");
#endif
        std::smatch versionMatch;
 
        // Ensure version string is not corrupt
        if (!version_.empty() && /*regex allows version prefix instead of exact match */
            std::regex_search(version_, versionMatch, std::regex("^([[:digit:]]+\\.[[:digit:]]+\\.[[:digit:]]+).*")))
        {
            version = versionMatch.str(1); // in case the git revision number is given take only version number
        }
    }
 
    void operator()(std::promise<bool> prom)
    {
        std::array<int, 3> empty_version{0, 0, 0};
        std::array<int, 3> srv_app_version{};
        std::array<int, 3> srv_sharg_version{};
 
        std::ifstream version_file{cookie_path / (name + ".version")};
 
        if (version_file.is_open())
        {
            std::string line{};
            std::getline(version_file, line); // get first line which should only contain the version number of the app
 
            if (line != unregistered_app)
                srv_app_version = get_numbers_from_version_string(line);
#if !defined(NDEBUG)
            else
                std::cerr << message_unregistered_app;
#endif // !defined(NDEBUG)
 
            std::getline(version_file, line); // get second line which should only contain the version number of sharg
            srv_sharg_version = get_numbers_from_version_string(line);
 
            version_file.close();
        }
 
#if !defined(NDEBUG) // only check Sharg version in debug
        if (srv_sharg_version != empty_version)
        {
            std::array<int, 3> sharg_version = {SHARG_VERSION_MAJOR, SHARG_VERSION_MINOR, SHARG_VERSION_PATCH};
 
            if (sharg_version < srv_sharg_version)
                std::cerr << message_sharg_update;
        }
#endif
 
        if (srv_app_version != empty_version) // app version
        {
#if defined(NDEBUG) // only check app version in release
            if (get_numbers_from_version_string(version) < srv_app_version)
                std::cerr << message_app_update;
#endif // defined(NDEBUG)
 
#if !defined(NDEBUG) // only notify developer that app version should be updated on server
            if (get_numbers_from_version_string(version) > srv_app_version)
                std::cerr << message_registered_app_update;
#endif // !defined(NDEBUG)
        }
 
        std::cerr << std::flush;
 
        std::string program = get_program();
 
        if (program.empty())
        {
            prom.set_value(false);
            return;
        }
 
        // 'cookie_path' is derived from environment variables and may contain any character, e.g. spaces.
        std::filesystem::path out_file = cookie_path / (name + ".version");
 
        // build up command for server call
        std::string command = program + // no user defined input
                              " " + quote_argument(out_file.string()) + " "
                            + std::string{"https://seqan-update.cs.uni-tuebingen.de/check/SeqAn-Sharg_"} +
#ifdef __linux
                              "Linux" +
#elif __APPLE__
                              "MacOS" +
#elif defined(_WIN32)
                              "Windows" +
#elif __FreeBSD__
                              "FreeBSD" +
#elif __OpenBSD__
                              "OpenBSD" +
#else
                              "unknown" +
#endif
#if __x86_64__ || __ppc64__
                              "_64_" +
#else
                              "_32_" +
#endif
                              name +          // !user input! escaped on construction of the parser
                              "_" + version + // !user input! escaped on construction of the version_checker
#if defined(_WIN32)
                              "; exit  [int] -not $?}\" > nul 2>&1";
#else
                              " > /dev/null 2>&1";
#endif
 
        // launch a separate thread to not defer runtime.
        std::thread(call_server, command, std::move(prom)).detach();
    }
 
    static std::filesystem::path get_path()
    {
        using namespace std::filesystem;
 
        path tmp_path;
 
        if (char * home_env = getenv(home_env_name); home_env != nullptr)
            tmp_path = std::string{home_env};
        tmp_path /= ".config";
 
        // First, create .config if it does not already exist.
        std::error_code err;
        create_directory(tmp_path, err);
 
        // If this did not fail we, create the seqan subdirectory.
        if (!err)
        {
            tmp_path /= "seqan"; // sharg is part of seqan, so the naming is fine.
            create_directory(tmp_path, err);
        }
 
        // .config/seqan cannot be created, try tmp directory.
        if (err)
        {
            tmp_path = temp_directory_path(err); // choose temp dir instead
 
            if (err) // e.g., TMPDIR is not a directory
            {
                tmp_path.clear(); // empty path signals no available directory to write to
                return tmp_path;
            }
        }
 
        // Check if files can be written inside dir. An existing file, e.g., in the temporary directory, might belong to
        // someone else and must not be opened. Hence, the probe file gets a unique name and std::ios::noreplace fails
        // instead of opening an existing file. In the unlikely case of a name clash, the directory is not used.
        path const dummy =
            tmp_path
            / ("dummy_" + std::to_string(std::chrono::steady_clock::now().time_since_epoch().count()) + ".txt");
        std::ofstream file{dummy, std::ios::out | std::ios::noreplace};
 
        bool is_open = file.is_open();
        bool is_good = file.good();
        file.close();
 
        if (is_open) // only remove the file if it was created here
            remove(dummy, err);
 
        if (!is_good || !is_open) // no write permissions
        {
            tmp_path.clear(); // empty path signals no available directory to write to, version check will not be done
        }
 
        return tmp_path;
    }
 
    static bool is_disabled(update_notifications developer_approval, std::optional<bool> user_approval)
    {
        return developer_approval == update_notifications::off || std::getenv("SHARG_NO_VERSION_CHECK") != nullptr
            || user_approval == false;
    }
 
    bool decide_if_check_is_performed(update_notifications developer_approval, std::optional<bool> user_approval)
    {
        if (is_disabled(developer_approval, user_approval))
            return false;
 
        if (cookie_path.empty()) // no directory to write the timestamp and version files to
        {
            // Like the question whether to perform the version check, the message is only shown interactively.
            if (detail::stdin_is_terminal() && detail::stderr_is_terminal()) // LCOV_EXCL_START
                std::cerr << message_no_writable_directory << std::flush;
            // LCOV_EXCL_STOP
            return false;
        }
 
        if (user_approval.has_value()) // the user explicitly enabled the version check
            return true;
 
        // version check was not explicitly handled so let's check the cookie
        if (std::filesystem::exists(cookie_path))
        {
            std::ifstream timestamp_file{timestamp_filename};
            std::string cookie_line{};
 
            if (timestamp_file.is_open())
            {
                std::getline(timestamp_file, cookie_line); // first line contains the timestamp
 
                if (get_time_diff_to_current(cookie_line) < 86400 /*one day in seconds*/)
                {
                    return false;
                }
 
                std::getline(timestamp_file, cookie_line); // second line contains the last user decision
 
                if (cookie_line == "NEVER")
                {
                    return false;
                }
                else if (cookie_line == "ALWAYS")
                {
                    return true;
                }
                // else we do not return but continue to ask the user
 
                timestamp_file.close();
            }
        }
 
        // Up until now, the user did not specify the --version-check option, the environment variable was not set,
        // nor did the the cookie tell us what to do. We will now ask the user if possible or do the check by default.
        write_cookie("ASK"); // Ask again next time when we read the cookie, if this is not overwritten.
 
        if (detail::stdin_is_terminal() && detail::stderr_is_terminal()) // LCOV_EXCL_START
        {
            std::cerr << R"(
#######################################################################
   Automatic Update Notifications
#######################################################################
 
 This app can look for updates automatically in the background,
 do you want to do that?
 
    [a] Always perform version checks for this app.
    [n] Never perform version checks for this app.
    [y] Yes, perform a version check now, and ask again tomorrow.
    [s] Skip the version check now, but ask again tomorrow (the default).
 
 Please enter one of [a, n, y, s] and press [RETURN].
 
 For more information, see:
 https://docs.seqan.de/sharg/main_user/about_update_notifications.html
 
#######################################################################
 
)";
            std::string line{};
            std::getline(std::cin, line);
            line.resize(1, 's'); // ignore everything but the first char or resizes the empty string to the default
 
            switch (line[0])
            {
            case 'y':
            {
                return true;
            }
            case 'a':
            {
                write_cookie(std::string{"ALWAYS"}); // overwrite cookie
                return true;
            }
            case 'n':
            {
                write_cookie(std::string{"NEVER"}); // overwrite cookie
                return false;
            }
            default:
            {
                return false;
            }
            }
        }
        else // of: if (detail::stdin_is_terminal() && detail::stderr_is_terminal())
        {
            return false; // default: do not check version today, if you cannot ask the user
        }
    } // LCOV_EXCL_STOP
 
    static constexpr std::string_view unregistered_app = "UNREGISTERED_APP";
    static constexpr std::string_view message_sharg_update =
        "[SHARG VERSION INFO] :: A new Sharg version is available online.\n"
        "[SHARG VERSION INFO] :: Please visit www.github.com/seqan/sharg-parser.git for an update\n"
        "[SHARG VERSION INFO] :: or inform the developer of this app.\n"
        "[SHARG VERSION INFO] :: If you don't wish to receive further notifications, set --version-check false.\n\n";
    static constexpr std::string_view message_unregistered_app =
        "[SHARG VERSION INFO] :: Thank you for using Sharg!\n"
        "[SHARG VERSION INFO] :: Do you wish to register your app for update notifications?\n"
        "[SHARG VERSION INFO] :: Just send an email to support@seqan.de with your app name and version number.\n"
        "[SHARG VERSION INFO] :: If you don't wish to receive further notifications, set --version-check false.\n\n";
    static constexpr std::string_view message_registered_app_update =
        "[APP VERSION INFO] :: We noticed the app version you use is newer than the one registered with us.\n"
        "[APP VERSION INFO] :: Please send us an email with the new version so we can correct it "
        "(support@seqan.de)\n\n";
    static constexpr std::string_view message_no_writable_directory =
        "[SHARG VERSION INFO] :: The version check was skipped because there is no writable directory for its files.\n"
        "[SHARG VERSION INFO] :: For details, see "
        "https://docs.seqan.de/sharg/main_user/about_update_notifications.html\n"
        "[SHARG VERSION INFO] :: If you don't wish to receive further notifications, set --version-check false.\n\n";
    std::string message_app_update =
        "[APP VERSION INFO] :: A new version of this application is now available.\n"
        "[APP VERSION INFO] :: If you don't wish to receive further notifications, set --version-check false.\n\n";
    /*Will be extended if a url is given on construction of version_check.*/
 
    static constexpr char const * home_env_name
    {
#if defined(_WIN32)
        "UserProfile"
#else
        "HOME"
#endif
    };
 
    std::string name;
    std::string version{"0.0.0"};
    std::regex version_regex{"^[[:digit:]]+\\.[[:digit:]]+\\.[[:digit:]]+$"};
    std::filesystem::path cookie_path = get_path();
    std::filesystem::path timestamp_filename;
 
private:
    static std::string get_program()
    {
#if defined(_WIN32)
        return "powershell.exe -NoLogo -NonInteractive -Command \"& {Invoke-WebRequest -erroraction 'silentlycontinue' "
               "-OutFile";
#else // Unix based platforms.
        if (!system("/usr/bin/env -i wget --version > /dev/null 2>&1"))
            return "/usr/bin/env -i wget --timeout=10 --tries=1 -q -O";
        else if (!system("/usr/bin/env -i curl --version > /dev/null 2>&1"))
            return "/usr/bin/env -i curl --connect-timeout 10 -o";
// In case neither wget nor curl is available try ftp/fetch if system is OpenBSD/FreeBSD.
// Note, both systems have ftp/fetch command installed by default so we do not guard against it.
#    if defined(__OpenBSD__)
        return "/usr/bin/env -i ftp -w10 -Vo";
#    elif defined(__FreeBSD__)
        return "/usr/bin/env -i fetch --timeout=10 -o";
#    else
        return "";
#    endif // __OpenBSD__
#endif     // defined(_WIN32)
    }
 
    double get_time_diff_to_current(std::string const & str_time) const
    {
        namespace co = std::chrono;
        double curr = co::duration_cast<co::seconds>(co::system_clock::now().time_since_epoch()).count();
 
        double d_time{};
        std::from_chars(str_time.data(), str_time.data() + str_time.size(), d_time);
 
        return curr - d_time;
    }
 
    std::array<int, 3> get_numbers_from_version_string(std::string const & str) const
    {
        std::array<int, 3> result{};
 
        if (!std::regex_match(str, version_regex))
            return result;
 
        auto res = std::from_chars(str.data(), str.data() + str.size(), result[0]); // stops and sets res.ptr at '.'
        res = std::from_chars(res.ptr + 1, str.data() + str.size(), result[1]);
        res = std::from_chars(res.ptr + 1, str.data() + str.size(), result[2]);
 
        return result;
    }
 
    template <typename msg_type>
    void write_cookie(msg_type && msg)
    {
        // The current time
        namespace co = std::chrono;
        auto curr = co::duration_cast<co::seconds>(co::system_clock::now().time_since_epoch()).count();
 
        std::ofstream timestamp_file{timestamp_filename};
 
        if (timestamp_file.is_open())
        {
            timestamp_file << curr << '\n' << msg;
            timestamp_file.close();
        }
    }
};
 
} // namespace sharg::detail