mirror of
https://github.com/tstack/lnav.git
synced 2024-08-16 08:20:29 +03:00
[internal] remove ghc::filesystem
This commit is contained in:
parent
9a1f383ce1
commit
53b883d015
@ -647,12 +647,6 @@ add_library(
|
|||||||
mapbox/variant.hpp
|
mapbox/variant.hpp
|
||||||
mapbox/variant_io.hpp
|
mapbox/variant_io.hpp
|
||||||
mapbox/variant_visitor.hpp
|
mapbox/variant_visitor.hpp
|
||||||
ghc/filesystem.hpp
|
|
||||||
ghc/fs_fwd.hpp
|
|
||||||
ghc/fs_impl.hpp
|
|
||||||
ghc/fs_std.hpp
|
|
||||||
ghc/fs_std_fwd.hpp
|
|
||||||
ghc/fs_std_impl.hpp
|
|
||||||
ww898/cp_utf8.hpp
|
ww898/cp_utf8.hpp
|
||||||
log_level_re.cc
|
log_level_re.cc
|
||||||
|
|
||||||
|
@ -379,12 +379,6 @@ noinst_HEADERS = \
|
|||||||
xpath_vtab.hh \
|
xpath_vtab.hh \
|
||||||
xterm_mouse.hh \
|
xterm_mouse.hh \
|
||||||
spookyhash/SpookyV2.h \
|
spookyhash/SpookyV2.h \
|
||||||
ghc/filesystem.hpp \
|
|
||||||
ghc/fs_fwd.hpp \
|
|
||||||
ghc/fs_impl.hpp \
|
|
||||||
ghc/fs_std.hpp \
|
|
||||||
ghc/fs_std_fwd.hpp \
|
|
||||||
ghc/fs_std_impl.hpp \
|
|
||||||
ww898/cp_utf8.hpp
|
ww898/cp_utf8.hpp
|
||||||
|
|
||||||
nodist_libdiag_a_SOURCES = \
|
nodist_libdiag_a_SOURCES = \
|
||||||
|
@ -52,7 +52,7 @@
|
|||||||
#include "fmt/format.h"
|
#include "fmt/format.h"
|
||||||
#include "hasher.hh"
|
#include "hasher.hh"
|
||||||
|
|
||||||
namespace fs = ghc::filesystem;
|
namespace fs = std::filesystem;
|
||||||
|
|
||||||
namespace archive_manager {
|
namespace archive_manager {
|
||||||
|
|
||||||
@ -269,7 +269,9 @@ extract(const std::string& filename, const extract_cb& cb)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
if (file_count > 0) {
|
if (file_count > 0) {
|
||||||
fs::last_write_time(done_path, std::chrono::system_clock::now());
|
auto now = std::filesystem::file_time_type{
|
||||||
|
std::chrono::system_clock::now().time_since_epoch()};
|
||||||
|
fs::last_write_time(done_path, now);
|
||||||
log_info("%s: archive has already been extracted!",
|
log_info("%s: archive has already been extracted!",
|
||||||
done_path.c_str());
|
done_path.c_str());
|
||||||
return Ok();
|
return Ok();
|
||||||
@ -399,7 +401,8 @@ void
|
|||||||
cleanup_cache()
|
cleanup_cache()
|
||||||
{
|
{
|
||||||
(void) std::async(std::launch::async, []() {
|
(void) std::async(std::launch::async, []() {
|
||||||
auto now = std::chrono::system_clock::now();
|
auto now = std::filesystem::file_time_type{
|
||||||
|
std::chrono::system_clock::now().time_since_epoch()};
|
||||||
auto cache_path = archive_cache_path();
|
auto cache_path = archive_cache_path();
|
||||||
const auto& cfg = injector::get<const config&>();
|
const auto& cfg = injector::get<const config&>();
|
||||||
std::vector<fs::path> to_remove;
|
std::vector<fs::path> to_remove;
|
||||||
|
@ -39,28 +39,28 @@
|
|||||||
|
|
||||||
#include "base/file_range.hh"
|
#include "base/file_range.hh"
|
||||||
#include "base/result.h"
|
#include "base/result.h"
|
||||||
#include "ghc/filesystem.hpp"
|
#include <filesystem>
|
||||||
#include "mapbox/variant.hpp"
|
#include "mapbox/variant.hpp"
|
||||||
|
|
||||||
namespace archive_manager {
|
namespace archive_manager {
|
||||||
|
|
||||||
struct extract_progress {
|
struct extract_progress {
|
||||||
extract_progress(ghc::filesystem::path path, ssize_t total)
|
extract_progress(std::filesystem::path path, ssize_t total)
|
||||||
: ep_path(std::move(path)), ep_total_size(total)
|
: ep_path(std::move(path)), ep_total_size(total)
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
|
||||||
const ghc::filesystem::path ep_path;
|
const std::filesystem::path ep_path;
|
||||||
const ssize_t ep_total_size;
|
const ssize_t ep_total_size;
|
||||||
std::atomic<size_t> ep_out_size{0};
|
std::atomic<size_t> ep_out_size{0};
|
||||||
};
|
};
|
||||||
|
|
||||||
using extract_cb
|
using extract_cb
|
||||||
= std::function<extract_progress*(const ghc::filesystem::path&, ssize_t)>;
|
= std::function<extract_progress*(const std::filesystem::path&, ssize_t)>;
|
||||||
|
|
||||||
struct archive_info {
|
struct archive_info {
|
||||||
struct entry {
|
struct entry {
|
||||||
ghc::filesystem::path e_name;
|
std::filesystem::path e_name;
|
||||||
const char* e_mode;
|
const char* e_mode;
|
||||||
time_t e_mtime;
|
time_t e_mtime;
|
||||||
std::optional<file_ssize_t> e_size;
|
std::optional<file_ssize_t> e_size;
|
||||||
@ -73,9 +73,9 @@ struct unknown_file {};
|
|||||||
using describe_result = mapbox::util::variant<archive_info, unknown_file>;
|
using describe_result = mapbox::util::variant<archive_info, unknown_file>;
|
||||||
|
|
||||||
Result<describe_result, std::string> describe(
|
Result<describe_result, std::string> describe(
|
||||||
const ghc::filesystem::path& filename);
|
const std::filesystem::path& filename);
|
||||||
|
|
||||||
ghc::filesystem::path filename_to_tmp_path(const std::string& filename);
|
std::filesystem::path filename_to_tmp_path(const std::string& filename);
|
||||||
|
|
||||||
using walk_result_t = Result<void, std::string>;
|
using walk_result_t = Result<void, std::string>;
|
||||||
|
|
||||||
@ -90,8 +90,8 @@ using walk_result_t = Result<void, std::string>;
|
|||||||
walk_result_t walk_archive_files(
|
walk_result_t walk_archive_files(
|
||||||
const std::string& filename,
|
const std::string& filename,
|
||||||
const extract_cb& cb,
|
const extract_cb& cb,
|
||||||
const std::function<void(const ghc::filesystem::path&,
|
const std::function<void(const std::filesystem::path&,
|
||||||
const ghc::filesystem::directory_entry&)>&);
|
const std::filesystem::directory_entry&)>&);
|
||||||
|
|
||||||
void cleanup_cache();
|
void cleanup_cache();
|
||||||
|
|
||||||
|
@ -27,6 +27,8 @@
|
|||||||
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
#include <fstream>
|
||||||
|
|
||||||
#include "fs_util.hh"
|
#include "fs_util.hh"
|
||||||
|
|
||||||
#include <stdlib.h>
|
#include <stdlib.h>
|
||||||
@ -41,7 +43,7 @@ namespace lnav {
|
|||||||
namespace filesystem {
|
namespace filesystem {
|
||||||
|
|
||||||
std::string
|
std::string
|
||||||
escape_path(const ghc::filesystem::path& p)
|
escape_path(const std::filesystem::path& p)
|
||||||
{
|
{
|
||||||
auto p_str = p.string();
|
auto p_str = p.string();
|
||||||
std::string retval;
|
std::string retval;
|
||||||
@ -70,8 +72,8 @@ escape_path(const ghc::filesystem::path& p)
|
|||||||
return retval;
|
return retval;
|
||||||
}
|
}
|
||||||
|
|
||||||
Result<ghc::filesystem::path, std::string>
|
Result<std::filesystem::path, std::string>
|
||||||
realpath(const ghc::filesystem::path& path)
|
realpath(const std::filesystem::path& path)
|
||||||
{
|
{
|
||||||
char resolved[PATH_MAX];
|
char resolved[PATH_MAX];
|
||||||
auto rc = ::realpath(path.c_str(), resolved);
|
auto rc = ::realpath(path.c_str(), resolved);
|
||||||
@ -80,11 +82,11 @@ realpath(const ghc::filesystem::path& path)
|
|||||||
return Err(std::string(strerror(errno)));
|
return Err(std::string(strerror(errno)));
|
||||||
}
|
}
|
||||||
|
|
||||||
return Ok(ghc::filesystem::path(resolved));
|
return Ok(std::filesystem::path(resolved));
|
||||||
}
|
}
|
||||||
|
|
||||||
Result<auto_fd, std::string>
|
Result<auto_fd, std::string>
|
||||||
create_file(const ghc::filesystem::path& path, int flags, mode_t mode)
|
create_file(const std::filesystem::path& path, int flags, mode_t mode)
|
||||||
{
|
{
|
||||||
auto fd = openp(path, flags | O_CREAT, mode);
|
auto fd = openp(path, flags | O_CREAT, mode);
|
||||||
|
|
||||||
@ -98,7 +100,7 @@ create_file(const ghc::filesystem::path& path, int flags, mode_t mode)
|
|||||||
}
|
}
|
||||||
|
|
||||||
Result<auto_fd, std::string>
|
Result<auto_fd, std::string>
|
||||||
open_file(const ghc::filesystem::path& path, int flags)
|
open_file(const std::filesystem::path& path, int flags)
|
||||||
{
|
{
|
||||||
auto fd = openp(path, flags);
|
auto fd = openp(path, flags);
|
||||||
|
|
||||||
@ -111,8 +113,8 @@ open_file(const ghc::filesystem::path& path, int flags)
|
|||||||
return Ok(auto_fd(fd));
|
return Ok(auto_fd(fd));
|
||||||
}
|
}
|
||||||
|
|
||||||
Result<std::pair<ghc::filesystem::path, auto_fd>, std::string>
|
Result<std::pair<std::filesystem::path, auto_fd>, std::string>
|
||||||
open_temp_file(const ghc::filesystem::path& pattern)
|
open_temp_file(const std::filesystem::path& pattern)
|
||||||
{
|
{
|
||||||
auto pattern_str = pattern.string();
|
auto pattern_str = pattern.string();
|
||||||
char pattern_copy[pattern_str.size() + 1];
|
char pattern_copy[pattern_str.size() + 1];
|
||||||
@ -126,14 +128,14 @@ open_temp_file(const ghc::filesystem::path& pattern)
|
|||||||
strerror(errno)));
|
strerror(errno)));
|
||||||
}
|
}
|
||||||
|
|
||||||
return Ok(std::make_pair(ghc::filesystem::path(pattern_copy), auto_fd(fd)));
|
return Ok(std::make_pair(std::filesystem::path(pattern_copy), auto_fd(fd)));
|
||||||
}
|
}
|
||||||
|
|
||||||
Result<std::string, std::string>
|
Result<std::string, std::string>
|
||||||
read_file(const ghc::filesystem::path& path)
|
read_file(const std::filesystem::path& path)
|
||||||
{
|
{
|
||||||
try {
|
try {
|
||||||
ghc::filesystem::ifstream file_stream(path);
|
std::ifstream file_stream(path);
|
||||||
|
|
||||||
if (!file_stream) {
|
if (!file_stream) {
|
||||||
return Err(std::string(strerror(errno)));
|
return Err(std::string(strerror(errno)));
|
||||||
@ -149,7 +151,7 @@ read_file(const ghc::filesystem::path& path)
|
|||||||
}
|
}
|
||||||
|
|
||||||
Result<write_file_result, std::string>
|
Result<write_file_result, std::string>
|
||||||
write_file(const ghc::filesystem::path& path,
|
write_file(const std::filesystem::path& path,
|
||||||
const string_fragment& content,
|
const string_fragment& content,
|
||||||
std::set<write_file_options> options)
|
std::set<write_file_options> options)
|
||||||
{
|
{
|
||||||
@ -175,11 +177,11 @@ write_file(const ghc::filesystem::path& path,
|
|||||||
|
|
||||||
std::error_code ec;
|
std::error_code ec;
|
||||||
if (options.count(write_file_options::backup_existing)) {
|
if (options.count(write_file_options::backup_existing)) {
|
||||||
if (ghc::filesystem::exists(path, ec)) {
|
if (std::filesystem::exists(path, ec)) {
|
||||||
auto backup_path = path;
|
auto backup_path = path;
|
||||||
|
|
||||||
backup_path += ".bak";
|
backup_path += ".bak";
|
||||||
ghc::filesystem::rename(path, backup_path, ec);
|
std::filesystem::rename(path, backup_path, ec);
|
||||||
if (ec) {
|
if (ec) {
|
||||||
return Err(
|
return Err(
|
||||||
fmt::format(FMT_STRING("unable to backup file {}: {}"),
|
fmt::format(FMT_STRING("unable to backup file {}: {}"),
|
||||||
@ -191,7 +193,7 @@ write_file(const ghc::filesystem::path& path,
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
ghc::filesystem::rename(tmp_pair.first, path, ec);
|
std::filesystem::rename(tmp_pair.first, path, ec);
|
||||||
if (ec) {
|
if (ec) {
|
||||||
return Err(
|
return Err(
|
||||||
fmt::format(FMT_STRING("unable to move temporary file {}: {}"),
|
fmt::format(FMT_STRING("unable to move temporary file {}: {}"),
|
||||||
@ -203,7 +205,7 @@ write_file(const ghc::filesystem::path& path,
|
|||||||
}
|
}
|
||||||
|
|
||||||
std::string
|
std::string
|
||||||
build_path(const std::vector<ghc::filesystem::path>& paths)
|
build_path(const std::vector<std::filesystem::path>& paths)
|
||||||
{
|
{
|
||||||
return paths
|
return paths
|
||||||
| lnav::itertools::map([](const auto& path) { return path.string(); })
|
| lnav::itertools::map([](const auto& path) { return path.string(); })
|
||||||
@ -220,7 +222,7 @@ build_path(const std::vector<ghc::filesystem::path>& paths)
|
|||||||
}
|
}
|
||||||
|
|
||||||
Result<struct stat, std::string>
|
Result<struct stat, std::string>
|
||||||
stat_file(const ghc::filesystem::path& path)
|
stat_file(const std::filesystem::path& path)
|
||||||
{
|
{
|
||||||
struct stat retval;
|
struct stat retval;
|
||||||
|
|
||||||
@ -233,7 +235,8 @@ stat_file(const ghc::filesystem::path& path)
|
|||||||
strerror(errno)));
|
strerror(errno)));
|
||||||
}
|
}
|
||||||
|
|
||||||
file_lock::file_lock(const ghc::filesystem::path& archive_path)
|
file_lock::
|
||||||
|
file_lock(const std::filesystem::path& archive_path)
|
||||||
{
|
{
|
||||||
auto lock_path = archive_path;
|
auto lock_path = archive_path;
|
||||||
|
|
||||||
@ -252,7 +255,7 @@ file_lock::file_lock(const ghc::filesystem::path& archive_path)
|
|||||||
namespace fmt {
|
namespace fmt {
|
||||||
|
|
||||||
auto
|
auto
|
||||||
formatter<ghc::filesystem::path>::format(const ghc::filesystem::path& p,
|
formatter<std::filesystem::path>::format(const std::filesystem::path& p,
|
||||||
format_context& ctx)
|
format_context& ctx)
|
||||||
-> decltype(ctx.out()) const
|
-> decltype(ctx.out()) const
|
||||||
{
|
{
|
||||||
|
@ -30,13 +30,16 @@
|
|||||||
#ifndef lnav_fs_util_hh
|
#ifndef lnav_fs_util_hh
|
||||||
#define lnav_fs_util_hh
|
#define lnav_fs_util_hh
|
||||||
|
|
||||||
|
#include <filesystem>
|
||||||
#include <optional>
|
#include <optional>
|
||||||
#include <set>
|
#include <set>
|
||||||
#include <string>
|
#include <string>
|
||||||
#include <vector>
|
#include <vector>
|
||||||
|
|
||||||
|
#include <sys/stat.h>
|
||||||
|
#include <unistd.h>
|
||||||
|
|
||||||
#include "auto_fd.hh"
|
#include "auto_fd.hh"
|
||||||
#include "ghc/filesystem.hpp"
|
|
||||||
#include "intern_string.hh"
|
#include "intern_string.hh"
|
||||||
#include "result.h"
|
#include "result.h"
|
||||||
|
|
||||||
@ -51,57 +54,57 @@ is_glob(const std::string& fn)
|
|||||||
|| fn.find('[') != std::string::npos);
|
|| fn.find('[') != std::string::npos);
|
||||||
}
|
}
|
||||||
|
|
||||||
std::string escape_path(const ghc::filesystem::path& p);
|
std::string escape_path(const std::filesystem::path& p);
|
||||||
|
|
||||||
inline int
|
inline int
|
||||||
statp(const ghc::filesystem::path& path, struct stat* buf)
|
statp(const std::filesystem::path& path, struct stat* buf)
|
||||||
{
|
{
|
||||||
return stat(path.c_str(), buf);
|
return stat(path.c_str(), buf);
|
||||||
}
|
}
|
||||||
|
|
||||||
inline int
|
inline int
|
||||||
openp(const ghc::filesystem::path& path, int flags)
|
openp(const std::filesystem::path& path, int flags)
|
||||||
{
|
{
|
||||||
return open(path.c_str(), flags);
|
return open(path.c_str(), flags);
|
||||||
}
|
}
|
||||||
|
|
||||||
inline int
|
inline int
|
||||||
openp(const ghc::filesystem::path& path, int flags, mode_t mode)
|
openp(const std::filesystem::path& path, int flags, mode_t mode)
|
||||||
{
|
{
|
||||||
return open(path.c_str(), flags, mode);
|
return open(path.c_str(), flags, mode);
|
||||||
}
|
}
|
||||||
|
|
||||||
Result<ghc::filesystem::path, std::string> realpath(
|
Result<std::filesystem::path, std::string> realpath(
|
||||||
const ghc::filesystem::path& path);
|
const std::filesystem::path& path);
|
||||||
|
|
||||||
Result<auto_fd, std::string> create_file(const ghc::filesystem::path& path,
|
Result<auto_fd, std::string> create_file(const std::filesystem::path& path,
|
||||||
int flags,
|
int flags,
|
||||||
mode_t mode);
|
mode_t mode);
|
||||||
|
|
||||||
Result<auto_fd, std::string> open_file(const ghc::filesystem::path& path,
|
Result<auto_fd, std::string> open_file(const std::filesystem::path& path,
|
||||||
int flags);
|
int flags);
|
||||||
|
|
||||||
Result<struct stat, std::string> stat_file(const ghc::filesystem::path& path);
|
Result<struct stat, std::string> stat_file(const std::filesystem::path& path);
|
||||||
|
|
||||||
Result<std::pair<ghc::filesystem::path, auto_fd>, std::string> open_temp_file(
|
Result<std::pair<std::filesystem::path, auto_fd>, std::string> open_temp_file(
|
||||||
const ghc::filesystem::path& pattern);
|
const std::filesystem::path& pattern);
|
||||||
|
|
||||||
Result<std::string, std::string> read_file(const ghc::filesystem::path& path);
|
Result<std::string, std::string> read_file(const std::filesystem::path& path);
|
||||||
|
|
||||||
enum class write_file_options {
|
enum class write_file_options {
|
||||||
backup_existing,
|
backup_existing,
|
||||||
};
|
};
|
||||||
|
|
||||||
struct write_file_result {
|
struct write_file_result {
|
||||||
std::optional<ghc::filesystem::path> wfr_backup_path;
|
std::optional<std::filesystem::path> wfr_backup_path;
|
||||||
};
|
};
|
||||||
|
|
||||||
Result<write_file_result, std::string> write_file(
|
Result<write_file_result, std::string> write_file(
|
||||||
const ghc::filesystem::path& path,
|
const std::filesystem::path& path,
|
||||||
const string_fragment& content,
|
const string_fragment& content,
|
||||||
std::set<write_file_options> options = {});
|
std::set<write_file_options> options = {});
|
||||||
|
|
||||||
std::string build_path(const std::vector<ghc::filesystem::path>& paths);
|
std::string build_path(const std::vector<std::filesystem::path>& paths);
|
||||||
|
|
||||||
class file_lock {
|
class file_lock {
|
||||||
public:
|
public:
|
||||||
@ -136,7 +139,7 @@ public:
|
|||||||
|
|
||||||
void unlock() const { lockf(this->lh_fd, F_ULOCK, 0); }
|
void unlock() const { lockf(this->lh_fd, F_ULOCK, 0); }
|
||||||
|
|
||||||
explicit file_lock(const ghc::filesystem::path& archive_path);
|
explicit file_lock(const std::filesystem::path& archive_path);
|
||||||
|
|
||||||
auto_fd lh_fd;
|
auto_fd lh_fd;
|
||||||
};
|
};
|
||||||
@ -146,9 +149,9 @@ public:
|
|||||||
|
|
||||||
namespace fmt {
|
namespace fmt {
|
||||||
template<>
|
template<>
|
||||||
struct formatter<ghc::filesystem::path> : formatter<string_view> {
|
struct formatter<std::filesystem::path> : formatter<string_view> {
|
||||||
auto format(const ghc::filesystem::path& p,
|
auto format(const std::filesystem::path& p, format_context& ctx)
|
||||||
format_context& ctx) -> decltype(ctx.out()) const;
|
-> decltype(ctx.out()) const;
|
||||||
};
|
};
|
||||||
} // namespace fmt
|
} // namespace fmt
|
||||||
|
|
||||||
|
@ -34,6 +34,8 @@
|
|||||||
# include <sstream>
|
# include <sstream>
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
#include <unistd.h>
|
||||||
|
|
||||||
#include "fmt/format.h"
|
#include "fmt/format.h"
|
||||||
#include "paths.hh"
|
#include "paths.hh"
|
||||||
|
|
||||||
@ -76,7 +78,7 @@ windows_to_unix_file_path(char* input)
|
|||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
ghc::filesystem::path
|
std::filesystem::path
|
||||||
dotlnav()
|
dotlnav()
|
||||||
{
|
{
|
||||||
#ifdef __CYGWIN__
|
#ifdef __CYGWIN__
|
||||||
@ -87,26 +89,26 @@ dotlnav()
|
|||||||
auto xdg_config_home = getenv("XDG_CONFIG_HOME");
|
auto xdg_config_home = getenv("XDG_CONFIG_HOME");
|
||||||
|
|
||||||
if (home_env != nullptr) {
|
if (home_env != nullptr) {
|
||||||
auto home_path = ghc::filesystem::path(home_env);
|
auto home_path = std::filesystem::path(home_env);
|
||||||
|
|
||||||
if (ghc::filesystem::is_directory(home_path)) {
|
if (std::filesystem::is_directory(home_path)) {
|
||||||
auto home_lnav = home_path / ".lnav";
|
auto home_lnav = home_path / ".lnav";
|
||||||
|
|
||||||
if (ghc::filesystem::is_directory(home_lnav)) {
|
if (std::filesystem::is_directory(home_lnav)) {
|
||||||
return home_lnav;
|
return home_lnav;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (xdg_config_home != nullptr) {
|
if (xdg_config_home != nullptr) {
|
||||||
auto xdg_path = ghc::filesystem::path(xdg_config_home);
|
auto xdg_path = std::filesystem::path(xdg_config_home);
|
||||||
|
|
||||||
if (ghc::filesystem::is_directory(xdg_path)) {
|
if (std::filesystem::is_directory(xdg_path)) {
|
||||||
return xdg_path / "lnav";
|
return xdg_path / "lnav";
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
auto home_config = home_path / ".config";
|
auto home_config = home_path / ".config";
|
||||||
|
|
||||||
if (ghc::filesystem::is_directory(home_config)) {
|
if (std::filesystem::is_directory(home_config)) {
|
||||||
return home_config / "lnav";
|
return home_config / "lnav";
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -114,16 +116,16 @@ dotlnav()
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
return ghc::filesystem::current_path();
|
return std::filesystem::current_path();
|
||||||
}
|
}
|
||||||
|
|
||||||
ghc::filesystem::path
|
std::filesystem::path
|
||||||
workdir()
|
workdir()
|
||||||
{
|
{
|
||||||
auto subdir_name = fmt::format(FMT_STRING("lnav-user-{}-work"), getuid());
|
auto subdir_name = fmt::format(FMT_STRING("lnav-user-{}-work"), getuid());
|
||||||
auto tmp_path = ghc::filesystem::temp_directory_path();
|
auto tmp_path = std::filesystem::temp_directory_path();
|
||||||
|
|
||||||
return tmp_path / ghc::filesystem::path(subdir_name);
|
return tmp_path / std::filesystem::path(subdir_name);
|
||||||
}
|
}
|
||||||
|
|
||||||
} // namespace paths
|
} // namespace paths
|
||||||
|
@ -30,7 +30,7 @@
|
|||||||
#ifndef lnav_paths_hh
|
#ifndef lnav_paths_hh
|
||||||
#define lnav_paths_hh
|
#define lnav_paths_hh
|
||||||
|
|
||||||
#include "ghc/filesystem.hpp"
|
#include <filesystem>
|
||||||
|
|
||||||
namespace lnav {
|
namespace lnav {
|
||||||
namespace paths {
|
namespace paths {
|
||||||
@ -48,9 +48,9 @@ char* windows_to_unix_file_path(char* input);
|
|||||||
* @param sub The path to the file in the '.lnav' directory.
|
* @param sub The path to the file in the '.lnav' directory.
|
||||||
* @return The full path
|
* @return The full path
|
||||||
*/
|
*/
|
||||||
ghc::filesystem::path dotlnav();
|
std::filesystem::path dotlnav();
|
||||||
|
|
||||||
ghc::filesystem::path workdir();
|
std::filesystem::path workdir();
|
||||||
|
|
||||||
} // namespace paths
|
} // namespace paths
|
||||||
} // namespace lnav
|
} // namespace lnav
|
||||||
|
@ -42,7 +42,7 @@ namespace piper {
|
|||||||
|
|
||||||
const char HEADER_MAGIC[4] = {'L', 0, 'N', 1};
|
const char HEADER_MAGIC[4] = {'L', 0, 'N', 1};
|
||||||
|
|
||||||
const ghc::filesystem::path&
|
const std::filesystem::path&
|
||||||
storage_path()
|
storage_path()
|
||||||
{
|
{
|
||||||
static auto INSTANCE = lnav::paths::workdir() / "piper";
|
static auto INSTANCE = lnav::paths::workdir() / "piper";
|
||||||
|
@ -39,7 +39,7 @@
|
|||||||
|
|
||||||
#include "auto_mem.hh"
|
#include "auto_mem.hh"
|
||||||
#include "base/intern_string.hh"
|
#include "base/intern_string.hh"
|
||||||
#include "ghc/filesystem.hpp"
|
#include <filesystem>
|
||||||
#include "mapbox/variant_io.hpp"
|
#include "mapbox/variant_io.hpp"
|
||||||
#include "time_util.hh"
|
#include "time_util.hh"
|
||||||
|
|
||||||
@ -76,7 +76,7 @@ struct header {
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
const ghc::filesystem::path& storage_path();
|
const std::filesystem::path& storage_path();
|
||||||
|
|
||||||
constexpr size_t HEADER_SIZE = 8;
|
constexpr size_t HEADER_SIZE = 8;
|
||||||
extern const char HEADER_MAGIC[4];
|
extern const char HEADER_MAGIC[4];
|
||||||
|
@ -603,10 +603,10 @@ multiline_executor::final()
|
|||||||
}
|
}
|
||||||
|
|
||||||
static Result<std::string, lnav::console::user_message>
|
static Result<std::string, lnav::console::user_message>
|
||||||
execute_file_contents(exec_context& ec, const ghc::filesystem::path& path)
|
execute_file_contents(exec_context& ec, const std::filesystem::path& path)
|
||||||
{
|
{
|
||||||
static const ghc::filesystem::path stdin_path("-");
|
static const std::filesystem::path stdin_path("-");
|
||||||
static const ghc::filesystem::path dev_stdin_path("/dev/stdin");
|
static const std::filesystem::path dev_stdin_path("/dev/stdin");
|
||||||
|
|
||||||
std::string retval;
|
std::string retval;
|
||||||
FILE* file;
|
FILE* file;
|
||||||
@ -715,13 +715,13 @@ execute_file(exec_context& ec, const std::string& path_and_args)
|
|||||||
} else if (errno != ENOENT) {
|
} else if (errno != ENOENT) {
|
||||||
open_error = strerror(errno);
|
open_error = strerror(errno);
|
||||||
} else {
|
} else {
|
||||||
auto script_path = ghc::filesystem::path(script_name);
|
auto script_path = std::filesystem::path(script_name);
|
||||||
|
|
||||||
if (!script_path.is_absolute()) {
|
if (!script_path.is_absolute()) {
|
||||||
script_path = ec.ec_path_stack.back() / script_path;
|
script_path = ec.ec_path_stack.back() / script_path;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (ghc::filesystem::is_regular_file(script_path)) {
|
if (std::filesystem::is_regular_file(script_path)) {
|
||||||
struct script_metadata meta;
|
struct script_metadata meta;
|
||||||
|
|
||||||
meta.sm_path = script_path;
|
meta.sm_path = script_path;
|
||||||
@ -1066,7 +1066,7 @@ pipe_callback(exec_context& ec, const std::string& cmdline, auto_fd& fd)
|
|||||||
});
|
});
|
||||||
}
|
}
|
||||||
std::error_code errc;
|
std::error_code errc;
|
||||||
ghc::filesystem::create_directories(lnav::paths::workdir(), errc);
|
std::filesystem::create_directories(lnav::paths::workdir(), errc);
|
||||||
auto open_temp_res = lnav::filesystem::open_temp_file(lnav::paths::workdir()
|
auto open_temp_res = lnav::filesystem::open_temp_file(lnav::paths::workdir()
|
||||||
/ "exec.XXXXXX");
|
/ "exec.XXXXXX");
|
||||||
if (open_temp_res.isErr()) {
|
if (open_temp_res.isErr()) {
|
||||||
|
@ -41,7 +41,7 @@
|
|||||||
#include "base/lnav.console.hh"
|
#include "base/lnav.console.hh"
|
||||||
#include "db_sub_source.hh"
|
#include "db_sub_source.hh"
|
||||||
#include "fmt/format.h"
|
#include "fmt/format.h"
|
||||||
#include "ghc/filesystem.hpp"
|
#include <filesystem>
|
||||||
#include "help_text.hh"
|
#include "help_text.hh"
|
||||||
#include "shlex.resolver.hh"
|
#include "shlex.resolver.hh"
|
||||||
#include "vis_line.hh"
|
#include "vis_line.hh"
|
||||||
@ -301,7 +301,7 @@ struct exec_context {
|
|||||||
std::stack<std::map<std::string, scoped_value_t>> ec_local_vars;
|
std::stack<std::map<std::string, scoped_value_t>> ec_local_vars;
|
||||||
std::vector<provenance_t> ec_provenance;
|
std::vector<provenance_t> ec_provenance;
|
||||||
std::map<std::string, scoped_value_t> ec_global_vars;
|
std::map<std::string, scoped_value_t> ec_global_vars;
|
||||||
std::vector<ghc::filesystem::path> ec_path_stack;
|
std::vector<std::filesystem::path> ec_path_stack;
|
||||||
std::vector<lnav::console::snippet> ec_source;
|
std::vector<lnav::console::snippet> ec_source;
|
||||||
help_text* ec_current_help{nullptr};
|
help_text* ec_current_help{nullptr};
|
||||||
|
|
||||||
|
@ -191,7 +191,9 @@ curl_request::complete(CURLcode result)
|
|||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
curl_looper::curl_looper() : cl_curl_multi(curl_multi_cleanup)
|
curl_looper::
|
||||||
|
curl_looper()
|
||||||
|
: cl_curl_multi(curl_multi_cleanup)
|
||||||
{
|
{
|
||||||
this->cl_curl_multi.reset(curl_multi_init());
|
this->cl_curl_multi.reset(curl_multi_init());
|
||||||
}
|
}
|
||||||
|
@ -61,7 +61,7 @@ dump_internals(const char* internals_dir)
|
|||||||
|
|
||||||
execute_examples();
|
execute_examples();
|
||||||
|
|
||||||
auto cmd_ref_path = ghc::filesystem::path(internals_dir) / "cmd-ref.rst";
|
auto cmd_ref_path = std::filesystem::path(internals_dir) / "cmd-ref.rst";
|
||||||
auto cmd_file = std::unique_ptr<FILE, decltype(&fclose)>(
|
auto cmd_file = std::unique_ptr<FILE, decltype(&fclose)>(
|
||||||
fopen(cmd_ref_path.c_str(), "w+"), fclose);
|
fopen(cmd_ref_path.c_str(), "w+"), fclose);
|
||||||
|
|
||||||
@ -78,7 +78,7 @@ dump_internals(const char* internals_dir)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
auto sql_ref_path = ghc::filesystem::path(internals_dir) / "sql-ref.rst";
|
auto sql_ref_path = std::filesystem::path(internals_dir) / "sql-ref.rst";
|
||||||
auto sql_file = std::unique_ptr<FILE, decltype(&fclose)>(
|
auto sql_file = std::unique_ptr<FILE, decltype(&fclose)>(
|
||||||
fopen(sql_ref_path.c_str(), "w+"), fclose);
|
fopen(sql_ref_path.c_str(), "w+"), fclose);
|
||||||
std::set<const help_text*> unique_sql_help;
|
std::set<const help_text*> unique_sql_help;
|
||||||
|
@ -162,7 +162,7 @@ file_collection::regenerate_unique_file_names()
|
|||||||
safe::ReadAccess<safe_name_to_errors> errs(*this->fc_name_to_errors);
|
safe::ReadAccess<safe_name_to_errors> errs(*this->fc_name_to_errors);
|
||||||
|
|
||||||
for (const auto& pair : *errs) {
|
for (const auto& pair : *errs) {
|
||||||
auto path = ghc::filesystem::path(pair.first).filename().string();
|
auto path = std::filesystem::path(pair.first).filename().string();
|
||||||
|
|
||||||
if (path.length() > this->fc_largest_path_length) {
|
if (path.length() > this->fc_largest_path_length) {
|
||||||
this->fc_largest_path_length = path.length();
|
this->fc_largest_path_length = path.length();
|
||||||
@ -182,7 +182,7 @@ file_collection::regenerate_unique_file_names()
|
|||||||
case file_format_t::ARCHIVE:
|
case file_format_t::ARCHIVE:
|
||||||
case file_format_t::MULTIPLEXED:
|
case file_format_t::MULTIPLEXED:
|
||||||
case file_format_t::SQLITE_DB: {
|
case file_format_t::SQLITE_DB: {
|
||||||
auto bn = ghc::filesystem::path(pair.first).filename().string();
|
auto bn = std::filesystem::path(pair.first).filename().string();
|
||||||
if (bn.length() > this->fc_largest_path_length) {
|
if (bn.length() > this->fc_largest_path_length) {
|
||||||
this->fc_largest_path_length = bn.length();
|
this->fc_largest_path_length = bn.length();
|
||||||
}
|
}
|
||||||
@ -307,7 +307,9 @@ file_collection::watch_logfile(const std::string& filename,
|
|||||||
int rc;
|
int rc;
|
||||||
|
|
||||||
auto filename_key = loo.loo_filename.empty() ? filename : loo.loo_filename;
|
auto filename_key = loo.loo_filename.empty() ? filename : loo.loo_filename;
|
||||||
if (this->fc_closed_files.count(filename)) {
|
if (this->fc_closed_files.count(filename)
|
||||||
|
|| this->fc_closed_files.count(filename_key))
|
||||||
|
{
|
||||||
return std::nullopt;
|
return std::nullopt;
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -464,7 +466,7 @@ file_collection::watch_logfile(const std::string& filename,
|
|||||||
},
|
},
|
||||||
[&filename, &retval](const auto& tmp_path,
|
[&filename, &retval](const auto& tmp_path,
|
||||||
const auto& entry) {
|
const auto& entry) {
|
||||||
auto arc_path = ghc::filesystem::relative(
|
auto arc_path = std::filesystem::relative(
|
||||||
entry.path(), tmp_path);
|
entry.path(), tmp_path);
|
||||||
auto custom_name = filename / arc_path;
|
auto custom_name = filename / arc_path;
|
||||||
bool is_visible = true;
|
bool is_visible = true;
|
||||||
|
@ -44,7 +44,7 @@
|
|||||||
|
|
||||||
namespace file_converter_manager {
|
namespace file_converter_manager {
|
||||||
|
|
||||||
static const ghc::filesystem::path&
|
static const std::filesystem::path&
|
||||||
cache_dir()
|
cache_dir()
|
||||||
{
|
{
|
||||||
static auto INSTANCE = lnav::paths::workdir() / "conversion";
|
static auto INSTANCE = lnav::paths::workdir() / "conversion";
|
||||||
@ -57,7 +57,7 @@ convert(const external_file_format& eff, const std::string& filename)
|
|||||||
{
|
{
|
||||||
log_info("attempting to convert file -- %s", filename.c_str());
|
log_info("attempting to convert file -- %s", filename.c_str());
|
||||||
|
|
||||||
ghc::filesystem::create_directories(cache_dir());
|
std::filesystem::create_directories(cache_dir());
|
||||||
auto outfile = TRY(lnav::filesystem::open_temp_file(
|
auto outfile = TRY(lnav::filesystem::open_temp_file(
|
||||||
cache_dir()
|
cache_dir()
|
||||||
/ fmt::format(FMT_STRING("{}.XXXXXX"), eff.eff_format_name)));
|
/ fmt::format(FMT_STRING("{}.XXXXXX"), eff.eff_format_name)));
|
||||||
@ -160,14 +160,15 @@ cleanup()
|
|||||||
{
|
{
|
||||||
(void) std::async(std::launch::async, []() {
|
(void) std::async(std::launch::async, []() {
|
||||||
const auto& cfg = injector::get<const lnav::piper::config&>();
|
const auto& cfg = injector::get<const lnav::piper::config&>();
|
||||||
auto now = std::chrono::system_clock::now();
|
auto now = std::filesystem::file_time_type{
|
||||||
|
std::chrono::system_clock::now().time_since_epoch()};
|
||||||
auto cache_path = cache_dir();
|
auto cache_path = cache_dir();
|
||||||
std::vector<ghc::filesystem::path> to_remove;
|
std::vector<std::filesystem::path> to_remove;
|
||||||
|
|
||||||
for (const auto& entry :
|
for (const auto& entry :
|
||||||
ghc::filesystem::directory_iterator(cache_path))
|
std::filesystem::directory_iterator(cache_path))
|
||||||
{
|
{
|
||||||
auto mtime = ghc::filesystem::last_write_time(entry.path());
|
auto mtime = std::filesystem::last_write_time(entry.path());
|
||||||
auto exp_time = mtime + cfg.c_ttl;
|
auto exp_time = mtime + cfg.c_ttl;
|
||||||
if (now < exp_time) {
|
if (now < exp_time) {
|
||||||
continue;
|
continue;
|
||||||
@ -178,7 +179,7 @@ cleanup()
|
|||||||
|
|
||||||
for (auto& entry : to_remove) {
|
for (auto& entry : to_remove) {
|
||||||
log_debug("removing conversion: %s", entry.c_str());
|
log_debug("removing conversion: %s", entry.c_str());
|
||||||
ghc::filesystem::remove_all(entry);
|
std::filesystem::remove_all(entry);
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
}
|
}
|
||||||
|
@ -37,13 +37,13 @@
|
|||||||
#include "base/auto_pid.hh"
|
#include "base/auto_pid.hh"
|
||||||
#include "base/result.h"
|
#include "base/result.h"
|
||||||
#include "file_format.hh"
|
#include "file_format.hh"
|
||||||
#include "ghc/filesystem.hpp"
|
#include <filesystem>
|
||||||
|
|
||||||
namespace file_converter_manager {
|
namespace file_converter_manager {
|
||||||
|
|
||||||
struct convert_result {
|
struct convert_result {
|
||||||
auto_pid<process_state::running> cr_child;
|
auto_pid<process_state::running> cr_child;
|
||||||
ghc::filesystem::path cr_destination;
|
std::filesystem::path cr_destination;
|
||||||
std::shared_ptr<std::vector<std::string>> cr_error_queue;
|
std::shared_ptr<std::vector<std::string>> cr_error_queue;
|
||||||
};
|
};
|
||||||
|
|
||||||
|
@ -40,7 +40,7 @@
|
|||||||
#include "line_buffer.hh"
|
#include "line_buffer.hh"
|
||||||
|
|
||||||
file_format_t
|
file_format_t
|
||||||
detect_file_format(const ghc::filesystem::path& filename)
|
detect_file_format(const std::filesystem::path& filename)
|
||||||
{
|
{
|
||||||
auto describe_res = archive_manager::describe(filename);
|
auto describe_res = archive_manager::describe(filename);
|
||||||
if (describe_res.isOk()
|
if (describe_res.isOk()
|
||||||
|
@ -35,7 +35,7 @@
|
|||||||
#include <optional>
|
#include <optional>
|
||||||
|
|
||||||
#include "fmt/format.h"
|
#include "fmt/format.h"
|
||||||
#include "ghc/filesystem.hpp"
|
#include <filesystem>
|
||||||
|
|
||||||
enum class file_format_t : int {
|
enum class file_format_t : int {
|
||||||
UNKNOWN,
|
UNKNOWN,
|
||||||
@ -48,13 +48,13 @@ enum class file_format_t : int {
|
|||||||
struct external_file_format {
|
struct external_file_format {
|
||||||
std::string eff_format_name;
|
std::string eff_format_name;
|
||||||
std::string eff_converter;
|
std::string eff_converter;
|
||||||
ghc::filesystem::path eff_source_path;
|
std::filesystem::path eff_source_path;
|
||||||
};
|
};
|
||||||
|
|
||||||
file_format_t detect_file_format(const ghc::filesystem::path& filename);
|
file_format_t detect_file_format(const std::filesystem::path& filename);
|
||||||
|
|
||||||
std::optional<external_file_format> detect_mime_type(
|
std::optional<external_file_format> detect_mime_type(
|
||||||
const ghc::filesystem::path& filename);
|
const std::filesystem::path& filename);
|
||||||
|
|
||||||
namespace fmt {
|
namespace fmt {
|
||||||
template<>
|
template<>
|
||||||
|
@ -115,9 +115,9 @@ file_options_collection::match(const std::string& path) const
|
|||||||
}
|
}
|
||||||
|
|
||||||
std::optional<std::pair<std::string, file_options>>
|
std::optional<std::pair<std::string, file_options>>
|
||||||
file_options_hier::match(const ghc::filesystem::path& path) const
|
file_options_hier::match(const std::filesystem::path& path) const
|
||||||
{
|
{
|
||||||
static const auto ROOT_PATH = ghc::filesystem::path("/");
|
static const auto ROOT_PATH = std::filesystem::path("/");
|
||||||
|
|
||||||
auto lookup_path = path.parent_path();
|
auto lookup_path = path.parent_path();
|
||||||
|
|
||||||
|
@ -35,7 +35,7 @@
|
|||||||
#include "base/lnav.console.hh"
|
#include "base/lnav.console.hh"
|
||||||
#include "base/result.h"
|
#include "base/result.h"
|
||||||
#include "date/tz.h"
|
#include "date/tz.h"
|
||||||
#include "ghc/filesystem.hpp"
|
#include <filesystem>
|
||||||
#include "mapbox/variant.hpp"
|
#include "mapbox/variant.hpp"
|
||||||
#include "safe/safe.h"
|
#include "safe/safe.h"
|
||||||
#include "yajlpp/yajlpp.hh"
|
#include "yajlpp/yajlpp.hh"
|
||||||
@ -66,12 +66,12 @@ struct file_options_collection {
|
|||||||
};
|
};
|
||||||
|
|
||||||
struct file_options_hier {
|
struct file_options_hier {
|
||||||
std::map<ghc::filesystem::path, file_options_collection>
|
std::map<std::filesystem::path, file_options_collection>
|
||||||
foh_path_to_collection;
|
foh_path_to_collection;
|
||||||
size_t foh_generation{0};
|
size_t foh_generation{0};
|
||||||
|
|
||||||
std::optional<std::pair<std::string, file_options>> match(
|
std::optional<std::pair<std::string, file_options>> match(
|
||||||
const ghc::filesystem::path& path) const;
|
const std::filesystem::path& path) const;
|
||||||
};
|
};
|
||||||
|
|
||||||
using safe_file_options_hier = safe::Safe<file_options_hier>;
|
using safe_file_options_hier = safe::Safe<file_options_hier>;
|
||||||
|
@ -268,7 +268,7 @@ files_sub_source::text_value_for_line(textview_curses& tc,
|
|||||||
|
|
||||||
if (line < errs->size()) {
|
if (line < errs->size()) {
|
||||||
auto iter = std::next(errs->begin(), line);
|
auto iter = std::next(errs->begin(), line);
|
||||||
auto path = ghc::filesystem::path(iter->first);
|
auto path = std::filesystem::path(iter->first);
|
||||||
auto fn = fmt::to_string(path.filename());
|
auto fn = fmt::to_string(path.filename());
|
||||||
|
|
||||||
truncate_to(fn, filename_width);
|
truncate_to(fn, filename_width);
|
||||||
@ -293,7 +293,7 @@ files_sub_source::text_value_for_line(textview_curses& tc,
|
|||||||
|
|
||||||
if (line < fc.fc_other_files.size()) {
|
if (line < fc.fc_other_files.size()) {
|
||||||
auto iter = std::next(fc.fc_other_files.begin(), line);
|
auto iter = std::next(fc.fc_other_files.begin(), line);
|
||||||
auto path = ghc::filesystem::path(iter->first);
|
auto path = std::filesystem::path(iter->first);
|
||||||
auto fn = fmt::to_string(path);
|
auto fn = fmt::to_string(path);
|
||||||
|
|
||||||
truncate_to(fn, filename_width);
|
truncate_to(fn, filename_width);
|
||||||
@ -322,7 +322,7 @@ files_sub_source::text_value_for_line(textview_curses& tc,
|
|||||||
|
|
||||||
const auto& lf = fc.fc_files[line];
|
const auto& lf = fc.fc_files[line];
|
||||||
auto ld_opt = lnav_data.ld_log_source.find_data(lf);
|
auto ld_opt = lnav_data.ld_log_source.find_data(lf);
|
||||||
auto fn = fmt::to_string(ghc::filesystem::path(lf->get_unique_path()));
|
auto fn = fmt::to_string(std::filesystem::path(lf->get_unique_path()));
|
||||||
char start_time[64] = "", end_time[64] = "";
|
char start_time[64] = "", end_time[64] = "";
|
||||||
std::vector<std::string> file_notes;
|
std::vector<std::string> file_notes;
|
||||||
|
|
||||||
|
@ -41,7 +41,7 @@
|
|||||||
#include "base/lnav_log.hh"
|
#include "base/lnav_log.hh"
|
||||||
#include "bound_tags.hh"
|
#include "bound_tags.hh"
|
||||||
#include "config.h"
|
#include "config.h"
|
||||||
#include "ghc/filesystem.hpp"
|
#include <filesystem>
|
||||||
#include "sql_help.hh"
|
#include "sql_help.hh"
|
||||||
#include "sql_util.hh"
|
#include "sql_util.hh"
|
||||||
#include "vtab_module.hh"
|
#include "vtab_module.hh"
|
||||||
@ -338,7 +338,7 @@ CREATE TABLE fstat (
|
|||||||
SQLITE_TRANSIENT);
|
SQLITE_TRANSIENT);
|
||||||
break;
|
break;
|
||||||
case FSTAT_COL_DATA: {
|
case FSTAT_COL_DATA: {
|
||||||
auto fs_path = ghc::filesystem::path{path};
|
auto fs_path = std::filesystem::path{path};
|
||||||
if (!vc.c_error.empty()) {
|
if (!vc.c_error.empty()) {
|
||||||
sqlite3_result_null(ctx);
|
sqlite3_result_null(ctx);
|
||||||
} else if (S_ISREG(vc.c_stat.st_mode)) {
|
} else if (S_ISREG(vc.c_stat.st_mode)) {
|
||||||
@ -370,7 +370,7 @@ CREATE TABLE fstat (
|
|||||||
to_sqlite(ctx, blob_auto_buffer{std::move(buffer)});
|
to_sqlite(ctx, blob_auto_buffer{std::move(buffer)});
|
||||||
}
|
}
|
||||||
} else if (S_ISLNK(vc.c_stat.st_mode)) {
|
} else if (S_ISLNK(vc.c_stat.st_mode)) {
|
||||||
auto link_path = ghc::filesystem::read_symlink(fs_path);
|
auto link_path = std::filesystem::read_symlink(fs_path);
|
||||||
|
|
||||||
to_sqlite(ctx, link_path.string());
|
to_sqlite(ctx, link_path.string());
|
||||||
} else {
|
} else {
|
||||||
|
File diff suppressed because it is too large
Load Diff
@ -1,38 +0,0 @@
|
|||||||
//---------------------------------------------------------------------------------------
|
|
||||||
//
|
|
||||||
// ghc::filesystem - A C++17-like filesystem implementation for C++11/C++14
|
|
||||||
//
|
|
||||||
//---------------------------------------------------------------------------------------
|
|
||||||
//
|
|
||||||
// Copyright (c) 2018, Steffen Schümann <s.schuemann@pobox.com>
|
|
||||||
//
|
|
||||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
||||||
// of this software and associated documentation files (the "Software"), to deal
|
|
||||||
// in the Software without restriction, including without limitation the rights
|
|
||||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
||||||
// copies of the Software, and to permit persons to whom the Software is
|
|
||||||
// furnished to do so, subject to the following conditions:
|
|
||||||
//
|
|
||||||
// The above copyright notice and this permission notice shall be included in all
|
|
||||||
// copies or substantial portions of the Software.
|
|
||||||
//
|
|
||||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
||||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
||||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
||||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
||||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
||||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
||||||
// SOFTWARE.
|
|
||||||
//
|
|
||||||
//---------------------------------------------------------------------------------------
|
|
||||||
// fs_fwd.hpp - The forwarding header for the header/implementation seperated usage of
|
|
||||||
// ghc::filesystem.
|
|
||||||
// This file can be include at any place, where ghc::filesystem api is needed while
|
|
||||||
// not bleeding implementation details (e.g. system includes) into the global namespace,
|
|
||||||
// as long as one cpp includes fs_impl.hpp to deliver the matching implementations.
|
|
||||||
//---------------------------------------------------------------------------------------
|
|
||||||
#ifndef GHC_FILESYSTEM_FWD_H
|
|
||||||
#define GHC_FILESYSTEM_FWD_H
|
|
||||||
#define GHC_FILESYSTEM_FWD
|
|
||||||
#include <ghc/filesystem.hpp>
|
|
||||||
#endif // GHC_FILESYSTEM_FWD_H
|
|
@ -1,35 +0,0 @@
|
|||||||
//---------------------------------------------------------------------------------------
|
|
||||||
//
|
|
||||||
// ghc::filesystem - A C++17-like filesystem implementation for C++11/C++14
|
|
||||||
//
|
|
||||||
//---------------------------------------------------------------------------------------
|
|
||||||
//
|
|
||||||
// Copyright (c) 2018, Steffen Schümann <s.schuemann@pobox.com>
|
|
||||||
//
|
|
||||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
||||||
// of this software and associated documentation files (the "Software"), to deal
|
|
||||||
// in the Software without restriction, including without limitation the rights
|
|
||||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
||||||
// copies of the Software, and to permit persons to whom the Software is
|
|
||||||
// furnished to do so, subject to the following conditions:
|
|
||||||
//
|
|
||||||
// The above copyright notice and this permission notice shall be included in all
|
|
||||||
// copies or substantial portions of the Software.
|
|
||||||
//
|
|
||||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
||||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
||||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
||||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
||||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
||||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
||||||
// SOFTWARE.
|
|
||||||
//
|
|
||||||
//---------------------------------------------------------------------------------------
|
|
||||||
// fs_impl.hpp - The implementation header for the header/implementation seperated usage of
|
|
||||||
// ghc::filesystem.
|
|
||||||
// This file can be used to hide the implementation of ghc::filesystem into a single cpp.
|
|
||||||
// The cpp has to include this before including fs_fwd.hpp directly or via a different
|
|
||||||
// header to work.
|
|
||||||
//---------------------------------------------------------------------------------------
|
|
||||||
#define GHC_FILESYSTEM_IMPLEMENTATION
|
|
||||||
#include <ghc/filesystem.hpp>
|
|
@ -1,60 +0,0 @@
|
|||||||
//---------------------------------------------------------------------------------------
|
|
||||||
//
|
|
||||||
// ghc::filesystem - A C++17-like filesystem implementation for C++11/C++14
|
|
||||||
//
|
|
||||||
//---------------------------------------------------------------------------------------
|
|
||||||
//
|
|
||||||
// Copyright (c) 2018, Steffen Schümann <s.schuemann@pobox.com>
|
|
||||||
//
|
|
||||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
||||||
// of this software and associated documentation files (the "Software"), to deal
|
|
||||||
// in the Software without restriction, including without limitation the rights
|
|
||||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
||||||
// copies of the Software, and to permit persons to whom the Software is
|
|
||||||
// furnished to do so, subject to the following conditions:
|
|
||||||
//
|
|
||||||
// The above copyright notice and this permission notice shall be included in all
|
|
||||||
// copies or substantial portions of the Software.
|
|
||||||
//
|
|
||||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
||||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
||||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
||||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
||||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
||||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
||||||
// SOFTWARE.
|
|
||||||
//
|
|
||||||
//---------------------------------------------------------------------------------------
|
|
||||||
// fs_std.hpp - The dynamic switching header that includes std::filesystem if detected
|
|
||||||
// or ghc::filesystem if not, and makes the resulting API available in the
|
|
||||||
// namespace fs.
|
|
||||||
//---------------------------------------------------------------------------------------
|
|
||||||
#ifndef GHC_FILESYSTEM_STD_H
|
|
||||||
#define GHC_FILESYSTEM_STD_H
|
|
||||||
#if defined(__APPLE__)
|
|
||||||
#include <Availability.h>
|
|
||||||
#endif
|
|
||||||
#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || (defined(__cplusplus) && __cplusplus >= 201703L)) && defined(__has_include)
|
|
||||||
#if __has_include(<filesystem>) && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
|
|
||||||
#define GHC_USE_STD_FS
|
|
||||||
#include <filesystem>
|
|
||||||
namespace fs {
|
|
||||||
using namespace std::filesystem;
|
|
||||||
using ifstream = std::ifstream;
|
|
||||||
using ofstream = std::ofstream;
|
|
||||||
using fstream = std::fstream;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
#endif
|
|
||||||
#ifndef GHC_USE_STD_FS
|
|
||||||
//#define GHC_WIN_DISABLE_WSTRING_STORAGE_TYPE
|
|
||||||
#include <ghc/filesystem.hpp>
|
|
||||||
namespace fs {
|
|
||||||
using namespace ghc::filesystem;
|
|
||||||
using ifstream = ghc::filesystem::ifstream;
|
|
||||||
using ofstream = ghc::filesystem::ofstream;
|
|
||||||
using fstream = ghc::filesystem::fstream;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
#endif // GHC_FILESYSTEM_STD_H
|
|
||||||
|
|
@ -1,63 +0,0 @@
|
|||||||
//---------------------------------------------------------------------------------------
|
|
||||||
//
|
|
||||||
// ghc::filesystem - A C++17-like filesystem implementation for C++11/C++14
|
|
||||||
//
|
|
||||||
//---------------------------------------------------------------------------------------
|
|
||||||
//
|
|
||||||
// Copyright (c) 2018, Steffen Schümann <s.schuemann@pobox.com>
|
|
||||||
//
|
|
||||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
||||||
// of this software and associated documentation files (the "Software"), to deal
|
|
||||||
// in the Software without restriction, including without limitation the rights
|
|
||||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
||||||
// copies of the Software, and to permit persons to whom the Software is
|
|
||||||
// furnished to do so, subject to the following conditions:
|
|
||||||
//
|
|
||||||
// The above copyright notice and this permission notice shall be included in all
|
|
||||||
// copies or substantial portions of the Software.
|
|
||||||
//
|
|
||||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
||||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
||||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
||||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
||||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
||||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
||||||
// SOFTWARE.
|
|
||||||
//
|
|
||||||
//---------------------------------------------------------------------------------------
|
|
||||||
// fs_std_fwd.hpp - The forwarding header for the header/implementation seperated usage of
|
|
||||||
// ghc::filesystem that uses std::filesystem if it detects it.
|
|
||||||
// This file can be include at any place, where fs::filesystem api is needed while
|
|
||||||
// not bleeding implementation details (e.g. system includes) into the global namespace,
|
|
||||||
// as long as one cpp includes fs_std_impl.hpp to deliver the matching implementations.
|
|
||||||
//---------------------------------------------------------------------------------------
|
|
||||||
#ifndef GHC_FILESYSTEM_STD_FWD_H
|
|
||||||
#define GHC_FILESYSTEM_STD_FWD_H
|
|
||||||
#if defined(__APPLE__)
|
|
||||||
#include <Availability.h>
|
|
||||||
#endif
|
|
||||||
#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || (defined(__cplusplus) && __cplusplus >= 201703L)) && defined(__has_include)
|
|
||||||
#if __has_include(<filesystem>) && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
|
|
||||||
#define GHC_USE_STD_FS
|
|
||||||
#include <filesystem>
|
|
||||||
namespace fs {
|
|
||||||
using namespace std::filesystem;
|
|
||||||
using ifstream = std::ifstream;
|
|
||||||
using ofstream = std::ofstream;
|
|
||||||
using fstream = std::fstream;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
#endif
|
|
||||||
#ifndef GHC_USE_STD_FS
|
|
||||||
//#define GHC_WIN_DISABLE_WSTRING_STORAGE_TYPE
|
|
||||||
#define GHC_FILESYSTEM_FWD
|
|
||||||
#include <ghc/filesystem.hpp>
|
|
||||||
namespace fs {
|
|
||||||
using namespace ghc::filesystem;
|
|
||||||
using ifstream = ghc::filesystem::ifstream;
|
|
||||||
using ofstream = ghc::filesystem::ofstream;
|
|
||||||
using fstream = ghc::filesystem::fstream;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
#endif // GHC_FILESYSTEM_STD_FWD_H
|
|
||||||
|
|
@ -1,46 +0,0 @@
|
|||||||
//---------------------------------------------------------------------------------------
|
|
||||||
//
|
|
||||||
// ghc::filesystem - A C++17-like filesystem implementation for C++11/C++14
|
|
||||||
//
|
|
||||||
//---------------------------------------------------------------------------------------
|
|
||||||
//
|
|
||||||
// Copyright (c) 2018, Steffen Schümann <s.schuemann@pobox.com>
|
|
||||||
//
|
|
||||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
||||||
// of this software and associated documentation files (the "Software"), to deal
|
|
||||||
// in the Software without restriction, including without limitation the rights
|
|
||||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
||||||
// copies of the Software, and to permit persons to whom the Software is
|
|
||||||
// furnished to do so, subject to the following conditions:
|
|
||||||
//
|
|
||||||
// The above copyright notice and this permission notice shall be included in all
|
|
||||||
// copies or substantial portions of the Software.
|
|
||||||
//
|
|
||||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
||||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
||||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
||||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
||||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
||||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
||||||
// SOFTWARE.
|
|
||||||
//
|
|
||||||
//---------------------------------------------------------------------------------------
|
|
||||||
// fs_std_impl.hpp - The implementation header for the header/implementation seperated usage of
|
|
||||||
// ghc::filesystem that does nothing if std::filesystem is detected.
|
|
||||||
// This file can be used to hide the implementation of ghc::filesystem into a single cpp.
|
|
||||||
// The cpp has to include this before including fs_std_fwd.hpp directly or via a different
|
|
||||||
// header to work.
|
|
||||||
//---------------------------------------------------------------------------------------
|
|
||||||
#if defined(__APPLE__)
|
|
||||||
#include <Availability.h>
|
|
||||||
#endif
|
|
||||||
#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || (defined(__cplusplus) && __cplusplus >= 201703L)) && defined(__has_include)
|
|
||||||
#if __has_include(<filesystem>) && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
|
|
||||||
#define GHC_USE_STD_FS
|
|
||||||
#endif
|
|
||||||
#endif
|
|
||||||
#ifndef GHC_USE_STD_FS
|
|
||||||
//#define GHC_WIN_DISABLE_WSTRING_STORAGE_TYPE
|
|
||||||
#define GHC_FILESYSTEM_IMPLEMENTATION
|
|
||||||
#include <ghc/filesystem.hpp>
|
|
||||||
#endif
|
|
@ -135,7 +135,8 @@ private:
|
|||||||
|
|
||||||
#define Z_BUFSIZE 65536U
|
#define Z_BUFSIZE 65536U
|
||||||
#define SYNCPOINT_SIZE (1024 * 1024)
|
#define SYNCPOINT_SIZE (1024 * 1024)
|
||||||
line_buffer::gz_indexed::gz_indexed()
|
line_buffer::gz_indexed::
|
||||||
|
gz_indexed()
|
||||||
{
|
{
|
||||||
if ((this->inbuf = auto_mem<Bytef>::malloc(Z_BUFSIZE)) == NULL) {
|
if ((this->inbuf = auto_mem<Bytef>::malloc(Z_BUFSIZE)) == NULL) {
|
||||||
throw std::bad_alloc();
|
throw std::bad_alloc();
|
||||||
@ -364,12 +365,14 @@ line_buffer::gz_indexed::read(void* buf, size_t offset, size_t size)
|
|||||||
return bytes;
|
return bytes;
|
||||||
}
|
}
|
||||||
|
|
||||||
line_buffer::line_buffer()
|
line_buffer::
|
||||||
|
line_buffer()
|
||||||
{
|
{
|
||||||
ensure(this->invariant());
|
ensure(this->invariant());
|
||||||
}
|
}
|
||||||
|
|
||||||
line_buffer::~line_buffer()
|
line_buffer::~
|
||||||
|
line_buffer()
|
||||||
{
|
{
|
||||||
if (this->lb_loader_future.valid()) {
|
if (this->lb_loader_future.valid()) {
|
||||||
this->lb_loader_future.wait();
|
this->lb_loader_future.wait();
|
||||||
@ -1312,8 +1315,8 @@ line_buffer::get_available()
|
|||||||
static_cast<file_ssize_t>(this->lb_buffer.size())};
|
static_cast<file_ssize_t>(this->lb_buffer.size())};
|
||||||
}
|
}
|
||||||
|
|
||||||
line_buffer::gz_indexed::indexDict::indexDict(const z_stream& s,
|
line_buffer::gz_indexed::indexDict::
|
||||||
const file_size_t size)
|
indexDict(const z_stream& s, const file_size_t size)
|
||||||
{
|
{
|
||||||
assert((s.data_type & GZ_END_OF_BLOCK_MASK));
|
assert((s.data_type & GZ_END_OF_BLOCK_MASK));
|
||||||
assert(!(s.data_type & GZ_END_OF_FILE_MASK));
|
assert(!(s.data_type & GZ_END_OF_FILE_MASK));
|
||||||
@ -1374,7 +1377,7 @@ line_buffer::quiesce()
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
static ghc::filesystem::path
|
static std::filesystem::path
|
||||||
line_buffer_cache_path()
|
line_buffer_cache_path()
|
||||||
{
|
{
|
||||||
return lnav::paths::workdir() / "buffer-cache";
|
return lnav::paths::workdir() / "buffer-cache";
|
||||||
@ -1405,7 +1408,7 @@ line_buffer::enable_cache()
|
|||||||
.to_string();
|
.to_string();
|
||||||
auto cache_dir = line_buffer_cache_path() / cached_base_name.substr(0, 2);
|
auto cache_dir = line_buffer_cache_path() / cached_base_name.substr(0, 2);
|
||||||
|
|
||||||
ghc::filesystem::create_directories(cache_dir);
|
std::filesystem::create_directories(cache_dir);
|
||||||
|
|
||||||
auto cached_file_name = fmt::format(FMT_STRING("{}.bin"), cached_base_name);
|
auto cached_file_name = fmt::format(FMT_STRING("{}.bin"), cached_base_name);
|
||||||
auto cached_file_path = cache_dir / cached_file_name;
|
auto cached_file_path = cache_dir / cached_file_name;
|
||||||
@ -1418,14 +1421,14 @@ line_buffer::enable_cache()
|
|||||||
auto fl = lnav::filesystem::file_lock(cached_file_path);
|
auto fl = lnav::filesystem::file_lock(cached_file_path);
|
||||||
auto guard = lnav::filesystem::file_lock::guard(&fl);
|
auto guard = lnav::filesystem::file_lock::guard(&fl);
|
||||||
|
|
||||||
if (ghc::filesystem::exists(cached_done_path)) {
|
if (std::filesystem::exists(cached_done_path)) {
|
||||||
log_info("%d:using existing cache file");
|
log_info("%d:using existing cache file");
|
||||||
auto open_res = lnav::filesystem::open_file(cached_file_path, O_RDWR);
|
auto open_res = lnav::filesystem::open_file(cached_file_path, O_RDWR);
|
||||||
if (open_res.isOk()) {
|
if (open_res.isOk()) {
|
||||||
this->lb_cached_fd = open_res.unwrap();
|
this->lb_cached_fd = open_res.unwrap();
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
ghc::filesystem::remove(cached_done_path);
|
std::filesystem::remove(cached_done_path);
|
||||||
}
|
}
|
||||||
|
|
||||||
auto create_res = lnav::filesystem::create_file(
|
auto create_res = lnav::filesystem::create_file(
|
||||||
@ -1470,18 +1473,19 @@ void
|
|||||||
line_buffer::cleanup_cache()
|
line_buffer::cleanup_cache()
|
||||||
{
|
{
|
||||||
(void) std::async(std::launch::async, []() {
|
(void) std::async(std::launch::async, []() {
|
||||||
auto now = std::chrono::system_clock::now();
|
auto now = std::filesystem::file_time_type{
|
||||||
|
std::chrono::system_clock::now().time_since_epoch()};
|
||||||
auto cache_path = line_buffer_cache_path();
|
auto cache_path = line_buffer_cache_path();
|
||||||
std::vector<ghc::filesystem::path> to_remove;
|
std::vector<std::filesystem::path> to_remove;
|
||||||
std::error_code ec;
|
std::error_code ec;
|
||||||
|
|
||||||
for (const auto& cache_subdir :
|
for (const auto& cache_subdir :
|
||||||
ghc::filesystem::directory_iterator(cache_path, ec))
|
std::filesystem::directory_iterator(cache_path, ec))
|
||||||
{
|
{
|
||||||
for (const auto& entry :
|
for (const auto& entry :
|
||||||
ghc::filesystem::directory_iterator(cache_subdir, ec))
|
std::filesystem::directory_iterator(cache_subdir, ec))
|
||||||
{
|
{
|
||||||
auto mtime = ghc::filesystem::last_write_time(entry.path());
|
auto mtime = std::filesystem::last_write_time(entry.path());
|
||||||
auto exp_time = mtime + 1h;
|
auto exp_time = mtime + 1h;
|
||||||
if (now < exp_time) {
|
if (now < exp_time) {
|
||||||
continue;
|
continue;
|
||||||
@ -1493,7 +1497,7 @@ line_buffer::cleanup_cache()
|
|||||||
|
|
||||||
for (auto& entry : to_remove) {
|
for (auto& entry : to_remove) {
|
||||||
log_debug("removing compressed file cache: %s", entry.c_str());
|
log_debug("removing compressed file cache: %s", entry.c_str());
|
||||||
ghc::filesystem::remove_all(entry, ec);
|
std::filesystem::remove_all(entry, ec);
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
}
|
}
|
||||||
|
22
src/lnav.cc
22
src/lnav.cc
@ -319,7 +319,7 @@ static bool
|
|||||||
append_default_files()
|
append_default_files()
|
||||||
{
|
{
|
||||||
bool retval = true;
|
bool retval = true;
|
||||||
auto cwd = ghc::filesystem::current_path();
|
auto cwd = std::filesystem::current_path();
|
||||||
|
|
||||||
for (const auto& path : DEFAULT_FILES) {
|
for (const auto& path : DEFAULT_FILES) {
|
||||||
if (access(path.c_str(), R_OK) == 0) {
|
if (access(path.c_str(), R_OK) == 0) {
|
||||||
@ -2135,7 +2135,9 @@ print_user_msgs(std::vector<lnav::console::user_message> error_list,
|
|||||||
|
|
||||||
if (warning_count > 0 && !mf.mf_print_warnings
|
if (warning_count > 0 && !mf.mf_print_warnings
|
||||||
&& !(lnav_data.ld_flags & LNF_HEADLESS)
|
&& !(lnav_data.ld_flags & LNF_HEADLESS)
|
||||||
&& (std::chrono::system_clock::now() - lnav_data.ld_last_dot_lnav_time
|
&& (std::filesystem::file_time_type{
|
||||||
|
std::chrono::system_clock::now().time_since_epoch()}
|
||||||
|
- lnav_data.ld_last_dot_lnav_time
|
||||||
> 24h))
|
> 24h))
|
||||||
{
|
{
|
||||||
lnav::console::print(
|
lnav::console::print(
|
||||||
@ -2239,7 +2241,7 @@ main(int argc, char* argv[])
|
|||||||
curr_tz,
|
curr_tz,
|
||||||
},
|
},
|
||||||
};
|
};
|
||||||
options_hier->foh_path_to_collection.emplace(ghc::filesystem::path("/"),
|
options_hier->foh_path_to_collection.emplace(std::filesystem::path("/"),
|
||||||
options_coll);
|
options_coll);
|
||||||
} catch (const std::runtime_error& e) {
|
} catch (const std::runtime_error& e) {
|
||||||
log_error("failed to setup tz: %s", e.what());
|
log_error("failed to setup tz: %s", e.what());
|
||||||
@ -2260,7 +2262,7 @@ main(int argc, char* argv[])
|
|||||||
auto dot_lnav_path = lnav::paths::dotlnav();
|
auto dot_lnav_path = lnav::paths::dotlnav();
|
||||||
std::error_code last_write_ec;
|
std::error_code last_write_ec;
|
||||||
lnav_data.ld_last_dot_lnav_time
|
lnav_data.ld_last_dot_lnav_time
|
||||||
= ghc::filesystem::last_write_time(dot_lnav_path, last_write_ec);
|
= std::filesystem::last_write_time(dot_lnav_path, last_write_ec);
|
||||||
|
|
||||||
ensure_dotlnav();
|
ensure_dotlnav();
|
||||||
|
|
||||||
@ -2625,7 +2627,7 @@ SELECT tbl_name FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL TABLE%'
|
|||||||
}
|
}
|
||||||
|
|
||||||
if (endswith(file_path, ".sql")) {
|
if (endswith(file_path, ".sql")) {
|
||||||
auto sql_path = ghc::filesystem::path(file_path);
|
auto sql_path = std::filesystem::path(file_path);
|
||||||
auto read_res = lnav::filesystem::read_file(sql_path);
|
auto read_res = lnav::filesystem::read_file(sql_path);
|
||||||
if (read_res.isErr()) {
|
if (read_res.isErr()) {
|
||||||
lnav::console::print(
|
lnav::console::print(
|
||||||
@ -2675,8 +2677,8 @@ SELECT tbl_name FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL TABLE%'
|
|||||||
}
|
}
|
||||||
auto file_type = file_type_result.unwrap();
|
auto file_type = file_type_result.unwrap();
|
||||||
|
|
||||||
auto src_path = ghc::filesystem::path(file_path);
|
auto src_path = std::filesystem::path(file_path);
|
||||||
ghc::filesystem::path dst_name;
|
std::filesystem::path dst_name;
|
||||||
if (file_type == config_file_type::CONFIG) {
|
if (file_type == config_file_type::CONFIG) {
|
||||||
dst_name = src_path.filename();
|
dst_name = src_path.filename();
|
||||||
} else {
|
} else {
|
||||||
@ -3031,7 +3033,7 @@ SELECT tbl_name FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL TABLE%'
|
|||||||
file_loc = file_path_str.substr(hash_index);
|
file_loc = file_path_str.substr(hash_index);
|
||||||
file_path_without_trailer = file_path_str.substr(0, hash_index);
|
file_path_without_trailer = file_path_str.substr(0, hash_index);
|
||||||
}
|
}
|
||||||
auto file_path = ghc::filesystem::path(
|
auto file_path = std::filesystem::path(
|
||||||
stat(file_path_without_trailer.c_str(), &st) == 0
|
stat(file_path_without_trailer.c_str(), &st) == 0
|
||||||
? file_path_without_trailer
|
? file_path_without_trailer
|
||||||
: file_path_str);
|
: file_path_str);
|
||||||
@ -3207,7 +3209,7 @@ SELECT tbl_name FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL TABLE%'
|
|||||||
}
|
}
|
||||||
|
|
||||||
std::optional<std::string> stdin_url;
|
std::optional<std::string> stdin_url;
|
||||||
ghc::filesystem::path stdin_dir;
|
std::filesystem::path stdin_dir;
|
||||||
if (load_stdin && !isatty(STDIN_FILENO) && !is_dev_null(STDIN_FILENO)
|
if (load_stdin && !isatty(STDIN_FILENO) && !is_dev_null(STDIN_FILENO)
|
||||||
&& !exec_stdin)
|
&& !exec_stdin)
|
||||||
{
|
{
|
||||||
@ -3555,7 +3557,7 @@ SELECT tbl_name FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL TABLE%'
|
|||||||
{
|
{
|
||||||
file_size_t stdin_size = 0;
|
file_size_t stdin_size = 0;
|
||||||
for (const auto& ent :
|
for (const auto& ent :
|
||||||
ghc::filesystem::directory_iterator(stdin_dir))
|
std::filesystem::directory_iterator(stdin_dir))
|
||||||
{
|
{
|
||||||
stdin_size += ent.file_size();
|
stdin_size += ent.file_size();
|
||||||
}
|
}
|
||||||
|
@ -82,7 +82,7 @@ typedef enum {
|
|||||||
} lnav_status_t;
|
} lnav_status_t;
|
||||||
|
|
||||||
using ppid_time_pair_t = std::pair<int, int>;
|
using ppid_time_pair_t = std::pair<int, int>;
|
||||||
using session_pair_t = std::pair<ppid_time_pair_t, ghc::filesystem::path>;
|
using session_pair_t = std::pair<ppid_time_pair_t, std::filesystem::path>;
|
||||||
|
|
||||||
class input_state_tracker : public log_state_dumper {
|
class input_state_tracker : public log_state_dumper {
|
||||||
public:
|
public:
|
||||||
@ -164,7 +164,7 @@ struct lnav_data_t {
|
|||||||
std::list<std::string> ld_commands;
|
std::list<std::string> ld_commands;
|
||||||
bool ld_cmd_init_done;
|
bool ld_cmd_init_done;
|
||||||
bool ld_session_loaded;
|
bool ld_session_loaded;
|
||||||
std::vector<ghc::filesystem::path> ld_config_paths;
|
std::vector<std::filesystem::path> ld_config_paths;
|
||||||
file_collection ld_active_files;
|
file_collection ld_active_files;
|
||||||
std::list<child_poller> ld_child_pollers;
|
std::list<child_poller> ld_child_pollers;
|
||||||
std::list<std::pair<std::string, file_location_t>> ld_files_to_front;
|
std::list<std::pair<std::string, file_location_t>> ld_files_to_front;
|
||||||
@ -261,7 +261,7 @@ struct lnav_data_t {
|
|||||||
|
|
||||||
lnav::func::scoped_cb ld_status_refresher;
|
lnav::func::scoped_cb ld_status_refresher;
|
||||||
|
|
||||||
ghc::filesystem::file_time_type ld_last_dot_lnav_time;
|
std::filesystem::file_time_type ld_last_dot_lnav_time;
|
||||||
};
|
};
|
||||||
|
|
||||||
struct static_service {};
|
struct static_service {};
|
||||||
|
@ -669,7 +669,7 @@ struct subcmd_format_t {
|
|||||||
auto ppath = regex101::patch_path(validate_res.unwrap(),
|
auto ppath = regex101::patch_path(validate_res.unwrap(),
|
||||||
en.re_permalink);
|
en.re_permalink);
|
||||||
|
|
||||||
if (ghc::filesystem::exists(ppath)) {
|
if (std::filesystem::exists(ppath)) {
|
||||||
return {
|
return {
|
||||||
console::user_message::error(
|
console::user_message::error(
|
||||||
attr_line_t("cannot delete regex101 entry "
|
attr_line_t("cannot delete regex101 entry "
|
||||||
@ -772,7 +772,7 @@ struct subcmd_piper_t {
|
|||||||
static perform_result_t list_action(const subcmd_piper_t&)
|
static perform_result_t list_action(const subcmd_piper_t&)
|
||||||
{
|
{
|
||||||
static const intern_string_t SRC = intern_string::lookup("piper");
|
static const intern_string_t SRC = intern_string::lookup("piper");
|
||||||
static const auto DOT_HEADER = ghc::filesystem::path(".header");
|
static const auto DOT_HEADER = std::filesystem::path(".header");
|
||||||
|
|
||||||
struct item {
|
struct item {
|
||||||
lnav::piper::header i_header;
|
lnav::piper::header i_header;
|
||||||
@ -784,7 +784,7 @@ struct subcmd_piper_t {
|
|||||||
std::vector<item> items;
|
std::vector<item> items;
|
||||||
std::error_code ec;
|
std::error_code ec;
|
||||||
|
|
||||||
for (const auto& instance_dir : ghc::filesystem::directory_iterator(
|
for (const auto& instance_dir : std::filesystem::directory_iterator(
|
||||||
lnav::piper::storage_path(), ec))
|
lnav::piper::storage_path(), ec))
|
||||||
{
|
{
|
||||||
if (!instance_dir.is_directory()) {
|
if (!instance_dir.is_directory()) {
|
||||||
@ -798,7 +798,7 @@ struct subcmd_piper_t {
|
|||||||
instance_dir.path().filename().string());
|
instance_dir.path().filename().string());
|
||||||
file_size_t total_size{0};
|
file_size_t total_size{0};
|
||||||
auto hdr_path = instance_dir / DOT_HEADER;
|
auto hdr_path = instance_dir / DOT_HEADER;
|
||||||
if (ghc::filesystem::exists(hdr_path)) {
|
if (std::filesystem::exists(hdr_path)) {
|
||||||
auto hdr_read_res = lnav::filesystem::read_file(hdr_path);
|
auto hdr_read_res = lnav::filesystem::read_file(hdr_path);
|
||||||
if (hdr_read_res.isOk()) {
|
if (hdr_read_res.isOk()) {
|
||||||
auto parse_res
|
auto parse_res
|
||||||
@ -822,7 +822,7 @@ struct subcmd_piper_t {
|
|||||||
}
|
}
|
||||||
|
|
||||||
for (const auto& entry :
|
for (const auto& entry :
|
||||||
ghc::filesystem::directory_iterator(instance_dir.path()))
|
std::filesystem::directory_iterator(instance_dir.path()))
|
||||||
{
|
{
|
||||||
if (entry.path().filename() == DOT_HEADER) {
|
if (entry.path().filename() == DOT_HEADER) {
|
||||||
continue;
|
continue;
|
||||||
@ -1007,7 +1007,7 @@ struct subcmd_piper_t {
|
|||||||
{
|
{
|
||||||
std::error_code ec;
|
std::error_code ec;
|
||||||
|
|
||||||
ghc::filesystem::remove_all(lnav::piper::storage_path(), ec);
|
std::filesystem::remove_all(lnav::piper::storage_path(), ec);
|
||||||
if (ec) {
|
if (ec) {
|
||||||
return {
|
return {
|
||||||
lnav::console::user_message::error(
|
lnav::console::user_message::error(
|
||||||
|
@ -385,7 +385,7 @@ com_set_file_timezone(exec_context& ec,
|
|||||||
const auto* tz = date::locate_zone(split_args[1]);
|
const auto* tz = date::locate_zone(split_args[1]);
|
||||||
auto pattern = split_args.size() == 2
|
auto pattern = split_args.size() == 2
|
||||||
? line_pair->first->get_filename()
|
? line_pair->first->get_filename()
|
||||||
: ghc::filesystem::path(split_args[2]);
|
: std::filesystem::path(split_args[2]);
|
||||||
|
|
||||||
if (!ec.ec_dry_run) {
|
if (!ec.ec_dry_run) {
|
||||||
static auto& safe_options_hier
|
static auto& safe_options_hier
|
||||||
@ -485,7 +485,7 @@ com_set_file_timezone_prompt(exec_context& ec, const std::string& cmdline)
|
|||||||
log_error("cannot get timezones: %s", e.what());
|
log_error("cannot get timezones: %s", e.what());
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
auto arg_path = ghc::filesystem::path(pattern_arg);
|
auto arg_path = std::filesystem::path(pattern_arg);
|
||||||
auto arg_parent = lnav::filesystem::escape_path(arg_path.parent_path());
|
auto arg_parent = lnav::filesystem::escape_path(arg_path.parent_path());
|
||||||
if (!endswith(arg_parent, "/")) {
|
if (!endswith(arg_parent, "/")) {
|
||||||
arg_parent += "/";
|
arg_parent += "/";
|
||||||
@ -3342,7 +3342,7 @@ com_open(exec_context& ec, std::string cmdline, std::vector<std::string>& args)
|
|||||||
fn_str);
|
fn_str);
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
auto fn = ghc::filesystem::path(fn_str);
|
auto fn = std::filesystem::path(fn_str);
|
||||||
auto detect_res = detect_file_format(fn);
|
auto detect_res = detect_file_format(fn);
|
||||||
attr_line_t al;
|
attr_line_t al;
|
||||||
attr_line_builder alb(al);
|
attr_line_builder alb(al);
|
||||||
@ -3542,7 +3542,7 @@ com_close(exec_context& ec, std::string cmdline, std::vector<std::string>& args)
|
|||||||
}
|
}
|
||||||
|
|
||||||
auto* tc = *lnav_data.ld_view_stack.top();
|
auto* tc = *lnav_data.ld_view_stack.top();
|
||||||
std::vector<std::optional<ghc::filesystem::path>> actual_path_v;
|
std::vector<std::optional<std::filesystem::path>> actual_path_v;
|
||||||
std::vector<std::string> fn_v;
|
std::vector<std::string> fn_v;
|
||||||
|
|
||||||
if (args.size() > 1) {
|
if (args.size() > 1) {
|
||||||
|
@ -168,9 +168,9 @@ ensure_dotlnav()
|
|||||||
if (glob(crash_glob.c_str(), GLOB_NOCHECK, nullptr, gl.inout()) == 0) {
|
if (glob(crash_glob.c_str(), GLOB_NOCHECK, nullptr, gl.inout()) == 0) {
|
||||||
std::error_code ec;
|
std::error_code ec;
|
||||||
for (size_t lpc = 0; lpc < gl->gl_pathc; lpc++) {
|
for (size_t lpc = 0; lpc < gl->gl_pathc; lpc++) {
|
||||||
auto crash_file = ghc::filesystem::path(gl->gl_pathv[lpc]);
|
auto crash_file = std::filesystem::path(gl->gl_pathv[lpc]);
|
||||||
|
|
||||||
ghc::filesystem::rename(
|
std::filesystem::rename(
|
||||||
crash_file, crash_dir_path / crash_file.filename(), ec);
|
crash_file, crash_dir_path / crash_file.filename(), ec);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -241,11 +241,11 @@ install_from_git(const std::string& repo)
|
|||||||
|
|
||||||
auto git_cmd = fork_res.unwrap();
|
auto git_cmd = fork_res.unwrap();
|
||||||
if (git_cmd.in_child()) {
|
if (git_cmd.in_child()) {
|
||||||
if (ghc::filesystem::is_directory(local_formats_path)) {
|
if (std::filesystem::is_directory(local_formats_path)) {
|
||||||
fmt::print("Updating format repo: {}\n", repo);
|
fmt::print("Updating format repo: {}\n", repo);
|
||||||
log_perror(chdir(local_formats_path.c_str()));
|
log_perror(chdir(local_formats_path.c_str()));
|
||||||
execlp("git", "git", "pull", nullptr);
|
execlp("git", "git", "pull", nullptr);
|
||||||
} else if (ghc::filesystem::is_directory(local_configs_path)) {
|
} else if (std::filesystem::is_directory(local_configs_path)) {
|
||||||
fmt::print("Updating config repo: {}\n", repo);
|
fmt::print("Updating config repo: {}\n", repo);
|
||||||
log_perror(chdir(local_configs_path.c_str()));
|
log_perror(chdir(local_configs_path.c_str()));
|
||||||
execlp("git", "git", "pull", nullptr);
|
execlp("git", "git", "pull", nullptr);
|
||||||
@ -266,12 +266,12 @@ install_from_git(const std::string& repo)
|
|||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (ghc::filesystem::is_directory(local_formats_path)
|
if (std::filesystem::is_directory(local_formats_path)
|
||||||
|| ghc::filesystem::is_directory(local_configs_path))
|
|| std::filesystem::is_directory(local_configs_path))
|
||||||
{
|
{
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
if (!ghc::filesystem::is_directory(local_staging_path)) {
|
if (!std::filesystem::is_directory(local_staging_path)) {
|
||||||
auto um
|
auto um
|
||||||
= lnav::console::user_message::error(
|
= lnav::console::user_message::error(
|
||||||
attr_line_t("failed to install git repo: ")
|
attr_line_t("failed to install git repo: ")
|
||||||
@ -293,7 +293,7 @@ install_from_git(const std::string& repo)
|
|||||||
|
|
||||||
if (glob(config_path.c_str(), 0, nullptr, gl.inout()) == 0) {
|
if (glob(config_path.c_str(), 0, nullptr, gl.inout()) == 0) {
|
||||||
for (size_t lpc = 0; lpc < gl->gl_pathc; lpc++) {
|
for (size_t lpc = 0; lpc < gl->gl_pathc; lpc++) {
|
||||||
auto file_path = ghc::filesystem::path{gl->gl_pathv[lpc]};
|
auto file_path = std::filesystem::path{gl->gl_pathv[lpc]};
|
||||||
|
|
||||||
if (file_path.extension() == ".lnav") {
|
if (file_path.extension() == ".lnav") {
|
||||||
found_lnav_file += 1;
|
found_lnav_file += 1;
|
||||||
@ -380,7 +380,7 @@ update_installs_from_git()
|
|||||||
if (glob(git_formats.c_str(), 0, nullptr, gl.inout()) == 0) {
|
if (glob(git_formats.c_str(), 0, nullptr, gl.inout()) == 0) {
|
||||||
for (int lpc = 0; lpc < (int) gl->gl_pathc; lpc++) {
|
for (int lpc = 0; lpc < (int) gl->gl_pathc; lpc++) {
|
||||||
auto git_dir
|
auto git_dir
|
||||||
= ghc::filesystem::path(gl->gl_pathv[lpc]).parent_path();
|
= std::filesystem::path(gl->gl_pathv[lpc]).parent_path();
|
||||||
|
|
||||||
printf("Updating formats in %s\n", git_dir.c_str());
|
printf("Updating formats in %s\n", git_dir.c_str());
|
||||||
auto pull_cmd = fmt::format(FMT_STRING("cd '{}' && git pull"),
|
auto pull_cmd = fmt::format(FMT_STRING("cd '{}' && git pull"),
|
||||||
@ -1723,7 +1723,7 @@ public:
|
|||||||
static active_key_map_listener KEYMAP_LISTENER;
|
static active_key_map_listener KEYMAP_LISTENER;
|
||||||
|
|
||||||
Result<config_file_type, std::string>
|
Result<config_file_type, std::string>
|
||||||
detect_config_file_type(const ghc::filesystem::path& path)
|
detect_config_file_type(const std::filesystem::path& path)
|
||||||
{
|
{
|
||||||
static const char* id_path[] = {"$schema", nullptr};
|
static const char* id_path[] = {"$schema", nullptr};
|
||||||
|
|
||||||
@ -1758,7 +1758,7 @@ detect_config_file_type(const ghc::filesystem::path& path)
|
|||||||
|
|
||||||
static void
|
static void
|
||||||
load_config_from(_lnav_config& lconfig,
|
load_config_from(_lnav_config& lconfig,
|
||||||
const ghc::filesystem::path& path,
|
const std::filesystem::path& path,
|
||||||
std::vector<lnav::console::user_message>& errors)
|
std::vector<lnav::console::user_message>& errors)
|
||||||
{
|
{
|
||||||
yajlpp_parse_context ypc(intern_string::lookup(path.string()),
|
yajlpp_parse_context ypc(intern_string::lookup(path.string()),
|
||||||
@ -1856,7 +1856,7 @@ load_default_configs(struct _lnav_config& config_obj,
|
|||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
load_config(const std::vector<ghc::filesystem::path>& extra_paths,
|
load_config(const std::vector<std::filesystem::path>& extra_paths,
|
||||||
std::vector<lnav::console::user_message>& errors)
|
std::vector<lnav::console::user_message>& errors)
|
||||||
{
|
{
|
||||||
auto user_config = lnav::paths::dotlnav() / "config.json";
|
auto user_config = lnav::paths::dotlnav() / "config.json";
|
||||||
|
@ -45,7 +45,7 @@
|
|||||||
#include "base/result.h"
|
#include "base/result.h"
|
||||||
#include "external_opener.cfg.hh"
|
#include "external_opener.cfg.hh"
|
||||||
#include "file_vtab.cfg.hh"
|
#include "file_vtab.cfg.hh"
|
||||||
#include "ghc/filesystem.hpp"
|
#include <filesystem>
|
||||||
#include "lnav_config_fwd.hh"
|
#include "lnav_config_fwd.hh"
|
||||||
#include "log.annotate.cfg.hh"
|
#include "log.annotate.cfg.hh"
|
||||||
#include "log_level.hh"
|
#include "log_level.hh"
|
||||||
@ -144,9 +144,9 @@ enum class config_file_type {
|
|||||||
};
|
};
|
||||||
|
|
||||||
Result<config_file_type, std::string> detect_config_file_type(
|
Result<config_file_type, std::string> detect_config_file_type(
|
||||||
const ghc::filesystem::path& path);
|
const std::filesystem::path& path);
|
||||||
|
|
||||||
void load_config(const std::vector<ghc::filesystem::path>& extra_paths,
|
void load_config(const std::vector<std::filesystem::path>& extra_paths,
|
||||||
std::vector<lnav::console::user_message>& errors);
|
std::vector<lnav::console::user_message>& errors);
|
||||||
|
|
||||||
void reset_config(const std::string& path);
|
void reset_config(const std::string& path);
|
||||||
|
@ -258,10 +258,10 @@ apply(vis_line_t vl, std::vector<intern_string_t> annos)
|
|||||||
nullptr,
|
nullptr,
|
||||||
};
|
};
|
||||||
|
|
||||||
std::vector<ghc::filesystem::path> path_v;
|
std::vector<std::filesystem::path> path_v;
|
||||||
|
|
||||||
auto src_path
|
auto src_path
|
||||||
= ghc::filesystem::path(
|
= std::filesystem::path(
|
||||||
iter->second.a_handler.pp_location.sl_source.to_string())
|
iter->second.a_handler.pp_location.sl_source.to_string())
|
||||||
.parent_path();
|
.parent_path();
|
||||||
path_v.push_back(src_path);
|
path_v.push_back(src_path);
|
||||||
|
@ -134,10 +134,10 @@ action_delegate::execute_action(const std::string& action_name)
|
|||||||
std::move(out_pipe.read_end()),
|
std::move(out_pipe.read_end()),
|
||||||
false,
|
false,
|
||||||
lnav::filesystem::open_temp_file(
|
lnav::filesystem::open_temp_file(
|
||||||
ghc::filesystem::temp_directory_path()
|
std::filesystem::temp_directory_path()
|
||||||
/ "lnav.action.XXXXXX")
|
/ "lnav.action.XXXXXX")
|
||||||
.map([](auto pair) {
|
.map([](auto pair) {
|
||||||
ghc::filesystem::remove(pair.first);
|
std::filesystem::remove(pair.first);
|
||||||
|
|
||||||
return pair;
|
return pair;
|
||||||
})
|
})
|
||||||
|
@ -2632,7 +2632,7 @@ using safe_format_header_expressions = safe::Safe<format_header_expressions>;
|
|||||||
static safe_format_header_expressions format_header_exprs;
|
static safe_format_header_expressions format_header_exprs;
|
||||||
|
|
||||||
std::optional<external_file_format>
|
std::optional<external_file_format>
|
||||||
detect_mime_type(const ghc::filesystem::path& filename)
|
detect_mime_type(const std::filesystem::path& filename)
|
||||||
{
|
{
|
||||||
uint8_t buffer[1024];
|
uint8_t buffer[1024];
|
||||||
size_t buffer_size = 0;
|
size_t buffer_size = 0;
|
||||||
|
@ -322,7 +322,7 @@ public:
|
|||||||
GRAPH_ORDERED_FORMATS;
|
GRAPH_ORDERED_FORMATS;
|
||||||
|
|
||||||
std::set<std::string> elf_source_path;
|
std::set<std::string> elf_source_path;
|
||||||
std::vector<ghc::filesystem::path> elf_format_source_order;
|
std::vector<std::filesystem::path> elf_format_source_order;
|
||||||
std::map<intern_string_t, int> elf_format_sources;
|
std::map<intern_string_t, int> elf_format_sources;
|
||||||
std::list<intern_string_t> elf_collision;
|
std::list<intern_string_t> elf_collision;
|
||||||
factory_container<lnav::pcre2pp::code> elf_filename_pcre;
|
factory_container<lnav::pcre2pp::code> elf_filename_pcre;
|
||||||
|
@ -69,7 +69,7 @@ static log_formats_map_t LOG_FORMATS;
|
|||||||
struct loader_userdata {
|
struct loader_userdata {
|
||||||
yajlpp_parse_context* ud_parse_context{nullptr};
|
yajlpp_parse_context* ud_parse_context{nullptr};
|
||||||
std::string ud_file_schema;
|
std::string ud_file_schema;
|
||||||
ghc::filesystem::path ud_format_path;
|
std::filesystem::path ud_format_path;
|
||||||
std::vector<intern_string_t>* ud_format_names{nullptr};
|
std::vector<intern_string_t>* ud_format_names{nullptr};
|
||||||
std::vector<lnav::console::user_message>* ud_errors{nullptr};
|
std::vector<lnav::console::user_message>* ud_errors{nullptr};
|
||||||
};
|
};
|
||||||
@ -1221,7 +1221,7 @@ format_error_reporter(const yajlpp_parse_context& ypc,
|
|||||||
}
|
}
|
||||||
|
|
||||||
std::vector<intern_string_t>
|
std::vector<intern_string_t>
|
||||||
load_format_file(const ghc::filesystem::path& filename,
|
load_format_file(const std::filesystem::path& filename,
|
||||||
std::vector<lnav::console::user_message>& errors)
|
std::vector<lnav::console::user_message>& errors)
|
||||||
{
|
{
|
||||||
std::vector<intern_string_t> retval;
|
std::vector<intern_string_t> retval;
|
||||||
@ -1310,7 +1310,7 @@ load_format_file(const ghc::filesystem::path& filename,
|
|||||||
}
|
}
|
||||||
|
|
||||||
static void
|
static void
|
||||||
load_from_path(const ghc::filesystem::path& path,
|
load_from_path(const std::filesystem::path& path,
|
||||||
std::vector<lnav::console::user_message>& errors)
|
std::vector<lnav::console::user_message>& errors)
|
||||||
{
|
{
|
||||||
auto format_path = path / "formats/*/*.json";
|
auto format_path = path / "formats/*/*.json";
|
||||||
@ -1319,7 +1319,7 @@ load_from_path(const ghc::filesystem::path& path,
|
|||||||
log_info("loading formats from path: %s", format_path.c_str());
|
log_info("loading formats from path: %s", format_path.c_str());
|
||||||
if (glob(format_path.c_str(), 0, nullptr, gl.inout()) == 0) {
|
if (glob(format_path.c_str(), 0, nullptr, gl.inout()) == 0) {
|
||||||
for (int lpc = 0; lpc < (int) gl->gl_pathc; lpc++) {
|
for (int lpc = 0; lpc < (int) gl->gl_pathc; lpc++) {
|
||||||
auto filepath = ghc::filesystem::path(gl->gl_pathv[lpc]);
|
auto filepath = std::filesystem::path(gl->gl_pathv[lpc]);
|
||||||
|
|
||||||
if (startswith(filepath.filename().string(), "config.")) {
|
if (startswith(filepath.filename().string(), "config.")) {
|
||||||
log_info(" not loading config as format: %s",
|
log_info(" not loading config as format: %s",
|
||||||
@ -1343,7 +1343,7 @@ load_from_path(const ghc::filesystem::path& path,
|
|||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
load_formats(const std::vector<ghc::filesystem::path>& extra_paths,
|
load_formats(const std::vector<std::filesystem::path>& extra_paths,
|
||||||
std::vector<lnav::console::user_message>& errors)
|
std::vector<lnav::console::user_message>& errors)
|
||||||
{
|
{
|
||||||
auto default_source = lnav::paths::dotlnav() / "default";
|
auto default_source = lnav::paths::dotlnav() / "default";
|
||||||
@ -1479,7 +1479,7 @@ load_formats(const std::vector<ghc::filesystem::path>& extra_paths,
|
|||||||
static void
|
static void
|
||||||
exec_sql_in_path(sqlite3* db,
|
exec_sql_in_path(sqlite3* db,
|
||||||
const std::map<std::string, scoped_value_t>& global_vars,
|
const std::map<std::string, scoped_value_t>& global_vars,
|
||||||
const ghc::filesystem::path& path,
|
const std::filesystem::path& path,
|
||||||
std::vector<lnav::console::user_message>& errors)
|
std::vector<lnav::console::user_message>& errors)
|
||||||
{
|
{
|
||||||
auto format_path = path / "formats/*/*.sql";
|
auto format_path = path / "formats/*/*.sql";
|
||||||
@ -1488,7 +1488,7 @@ exec_sql_in_path(sqlite3* db,
|
|||||||
log_info("executing SQL files in path: %s", format_path.c_str());
|
log_info("executing SQL files in path: %s", format_path.c_str());
|
||||||
if (glob(format_path.c_str(), 0, nullptr, gl.inout()) == 0) {
|
if (glob(format_path.c_str(), 0, nullptr, gl.inout()) == 0) {
|
||||||
for (int lpc = 0; lpc < (int) gl->gl_pathc; lpc++) {
|
for (int lpc = 0; lpc < (int) gl->gl_pathc; lpc++) {
|
||||||
auto filename = ghc::filesystem::path(gl->gl_pathv[lpc]);
|
auto filename = std::filesystem::path(gl->gl_pathv[lpc]);
|
||||||
auto read_res = lnav::filesystem::read_file(filename);
|
auto read_res = lnav::filesystem::read_file(filename);
|
||||||
|
|
||||||
if (read_res.isOk()) {
|
if (read_res.isOk()) {
|
||||||
@ -1511,7 +1511,7 @@ exec_sql_in_path(sqlite3* db,
|
|||||||
void
|
void
|
||||||
load_format_extra(sqlite3* db,
|
load_format_extra(sqlite3* db,
|
||||||
const std::map<std::string, scoped_value_t>& global_vars,
|
const std::map<std::string, scoped_value_t>& global_vars,
|
||||||
const std::vector<ghc::filesystem::path>& extra_paths,
|
const std::vector<std::filesystem::path>& extra_paths,
|
||||||
std::vector<lnav::console::user_message>& errors)
|
std::vector<lnav::console::user_message>& errors)
|
||||||
{
|
{
|
||||||
for (const auto& extra_path : extra_paths) {
|
for (const auto& extra_path : extra_paths) {
|
||||||
@ -1585,7 +1585,7 @@ extract_metadata_from_file(struct script_metadata& meta_inout)
|
|||||||
}
|
}
|
||||||
|
|
||||||
static void
|
static void
|
||||||
find_format_in_path(const ghc::filesystem::path& path,
|
find_format_in_path(const std::filesystem::path& path,
|
||||||
available_scripts& scripts)
|
available_scripts& scripts)
|
||||||
{
|
{
|
||||||
for (auto format_path :
|
for (auto format_path :
|
||||||
@ -1612,7 +1612,7 @@ find_format_in_path(const ghc::filesystem::path& path,
|
|||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
find_format_scripts(const std::vector<ghc::filesystem::path>& extra_paths,
|
find_format_scripts(const std::vector<std::filesystem::path>& extra_paths,
|
||||||
available_scripts& scripts)
|
available_scripts& scripts)
|
||||||
{
|
{
|
||||||
for (const auto& extra_path : extra_paths) {
|
for (const auto& extra_path : extra_paths) {
|
||||||
|
@ -39,16 +39,16 @@
|
|||||||
|
|
||||||
#include "base/intern_string.hh"
|
#include "base/intern_string.hh"
|
||||||
#include "base/lnav.console.hh"
|
#include "base/lnav.console.hh"
|
||||||
#include "ghc/filesystem.hpp"
|
#include <filesystem>
|
||||||
#include "shlex.resolver.hh"
|
#include "shlex.resolver.hh"
|
||||||
|
|
||||||
class log_vtab_manager;
|
class log_vtab_manager;
|
||||||
|
|
||||||
std::vector<intern_string_t> load_format_file(
|
std::vector<intern_string_t> load_format_file(
|
||||||
const ghc::filesystem::path& filename,
|
const std::filesystem::path& filename,
|
||||||
std::vector<lnav::console::user_message>& errors);
|
std::vector<lnav::console::user_message>& errors);
|
||||||
|
|
||||||
void load_formats(const std::vector<ghc::filesystem::path>& extra_paths,
|
void load_formats(const std::vector<std::filesystem::path>& extra_paths,
|
||||||
std::vector<lnav::console::user_message>& errors);
|
std::vector<lnav::console::user_message>& errors);
|
||||||
|
|
||||||
void load_format_vtabs(log_vtab_manager* vtab_manager,
|
void load_format_vtabs(log_vtab_manager* vtab_manager,
|
||||||
@ -56,11 +56,11 @@ void load_format_vtabs(log_vtab_manager* vtab_manager,
|
|||||||
|
|
||||||
void load_format_extra(sqlite3* db,
|
void load_format_extra(sqlite3* db,
|
||||||
const std::map<std::string, scoped_value_t>& global_vars,
|
const std::map<std::string, scoped_value_t>& global_vars,
|
||||||
const std::vector<ghc::filesystem::path>& extra_paths,
|
const std::vector<std::filesystem::path>& extra_paths,
|
||||||
std::vector<lnav::console::user_message>& errors);
|
std::vector<lnav::console::user_message>& errors);
|
||||||
|
|
||||||
struct script_metadata {
|
struct script_metadata {
|
||||||
ghc::filesystem::path sm_path;
|
std::filesystem::path sm_path;
|
||||||
std::string sm_name;
|
std::string sm_name;
|
||||||
std::string sm_synopsis;
|
std::string sm_synopsis;
|
||||||
std::string sm_description;
|
std::string sm_description;
|
||||||
@ -72,7 +72,7 @@ struct available_scripts {
|
|||||||
std::map<std::string, std::vector<script_metadata>> as_scripts;
|
std::map<std::string, std::vector<script_metadata>> as_scripts;
|
||||||
};
|
};
|
||||||
|
|
||||||
void find_format_scripts(const std::vector<ghc::filesystem::path>& extra_paths,
|
void find_format_scripts(const std::vector<std::filesystem::path>& extra_paths,
|
||||||
available_scripts& scripts);
|
available_scripts& scripts);
|
||||||
|
|
||||||
extern const struct json_path_container format_handlers;
|
extern const struct json_path_container format_handlers;
|
||||||
|
@ -70,7 +70,7 @@ static const typed_json_path_container<lnav::gzip::header> file_header_handlers
|
|||||||
};
|
};
|
||||||
|
|
||||||
Result<std::shared_ptr<logfile>, std::string>
|
Result<std::shared_ptr<logfile>, std::string>
|
||||||
logfile::open(ghc::filesystem::path filename,
|
logfile::open(std::filesystem::path filename,
|
||||||
const logfile_open_options& loo,
|
const logfile_open_options& loo,
|
||||||
auto_fd fd)
|
auto_fd fd)
|
||||||
{
|
{
|
||||||
@ -79,7 +79,7 @@ logfile::open(ghc::filesystem::path filename,
|
|||||||
auto lf = std::shared_ptr<logfile>(new logfile(std::move(filename), loo));
|
auto lf = std::shared_ptr<logfile>(new logfile(std::move(filename), loo));
|
||||||
|
|
||||||
memset(&lf->lf_stat, 0, sizeof(lf->lf_stat));
|
memset(&lf->lf_stat, 0, sizeof(lf->lf_stat));
|
||||||
ghc::filesystem::path resolved_path;
|
std::filesystem::path resolved_path;
|
||||||
|
|
||||||
if (!fd.has_value()) {
|
if (!fd.has_value()) {
|
||||||
auto rp_res = lnav::filesystem::realpath(lf->lf_filename);
|
auto rp_res = lnav::filesystem::realpath(lf->lf_filename);
|
||||||
@ -196,7 +196,7 @@ logfile::open(ghc::filesystem::path filename,
|
|||||||
return Ok(lf);
|
return Ok(lf);
|
||||||
}
|
}
|
||||||
|
|
||||||
logfile::logfile(ghc::filesystem::path filename,
|
logfile::logfile(std::filesystem::path filename,
|
||||||
const logfile_open_options& loo)
|
const logfile_open_options& loo)
|
||||||
: lf_filename(std::move(filename)), lf_options(loo)
|
: lf_filename(std::move(filename)), lf_options(loo)
|
||||||
{
|
{
|
||||||
@ -1297,7 +1297,7 @@ logfile::reobserve_from(iterator iter)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
ghc::filesystem::path
|
std::filesystem::path
|
||||||
logfile::get_path() const
|
logfile::get_path() const
|
||||||
{
|
{
|
||||||
return this->lf_filename;
|
return this->lf_filename;
|
||||||
@ -1420,7 +1420,7 @@ logfile::set_filename(const std::string& filename)
|
|||||||
{
|
{
|
||||||
if (this->lf_filename != filename) {
|
if (this->lf_filename != filename) {
|
||||||
this->lf_filename = filename;
|
this->lf_filename = filename;
|
||||||
ghc::filesystem::path p(filename);
|
std::filesystem::path p(filename);
|
||||||
this->lf_basename = p.filename();
|
this->lf_basename = p.filename();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -49,7 +49,7 @@
|
|||||||
#include "bookmarks.hh"
|
#include "bookmarks.hh"
|
||||||
#include "byte_array.hh"
|
#include "byte_array.hh"
|
||||||
#include "file_options.hh"
|
#include "file_options.hh"
|
||||||
#include "ghc/filesystem.hpp"
|
#include <filesystem>
|
||||||
#include "line_buffer.hh"
|
#include "line_buffer.hh"
|
||||||
#include "log_format_fwd.hh"
|
#include "log_format_fwd.hh"
|
||||||
#include "logfile_fwd.hh"
|
#include "logfile_fwd.hh"
|
||||||
@ -114,7 +114,7 @@ public:
|
|||||||
* descriptor needs to be seekable.
|
* descriptor needs to be seekable.
|
||||||
*/
|
*/
|
||||||
static Result<std::shared_ptr<logfile>, std::string> open(
|
static Result<std::shared_ptr<logfile>, std::string> open(
|
||||||
ghc::filesystem::path filename,
|
std::filesystem::path filename,
|
||||||
const logfile_open_options& loo,
|
const logfile_open_options& loo,
|
||||||
auto_fd fd = auto_fd{});
|
auto_fd fd = auto_fd{});
|
||||||
|
|
||||||
@ -122,13 +122,13 @@ public:
|
|||||||
|
|
||||||
const logfile_activity& get_activity() const { return this->lf_activity; }
|
const logfile_activity& get_activity() const { return this->lf_activity; }
|
||||||
|
|
||||||
std::optional<ghc::filesystem::path> get_actual_path() const
|
std::optional<std::filesystem::path> get_actual_path() const
|
||||||
{
|
{
|
||||||
return this->lf_actual_path;
|
return this->lf_actual_path;
|
||||||
}
|
}
|
||||||
|
|
||||||
/** @return The filename as given in the constructor. */
|
/** @return The filename as given in the constructor. */
|
||||||
const ghc::filesystem::path& get_filename() const
|
const std::filesystem::path& get_filename() const
|
||||||
{
|
{
|
||||||
return this->lf_filename;
|
return this->lf_filename;
|
||||||
}
|
}
|
||||||
@ -371,7 +371,7 @@ public:
|
|||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
ghc::filesystem::path get_path() const override;
|
std::filesystem::path get_path() const override;
|
||||||
|
|
||||||
enum class note_type {
|
enum class note_type {
|
||||||
indexing_disabled,
|
indexing_disabled,
|
||||||
@ -435,16 +435,16 @@ protected:
|
|||||||
void set_format_base_time(log_format* lf);
|
void set_format_base_time(log_format* lf);
|
||||||
|
|
||||||
private:
|
private:
|
||||||
logfile(ghc::filesystem::path filename, const logfile_open_options& loo);
|
logfile(std::filesystem::path filename, const logfile_open_options& loo);
|
||||||
|
|
||||||
bool file_options_have_changed();
|
bool file_options_have_changed();
|
||||||
|
|
||||||
ghc::filesystem::path lf_filename;
|
std::filesystem::path lf_filename;
|
||||||
logfile_open_options lf_options;
|
logfile_open_options lf_options;
|
||||||
logfile_activity lf_activity;
|
logfile_activity lf_activity;
|
||||||
bool lf_named_file{true};
|
bool lf_named_file{true};
|
||||||
bool lf_valid_filename{true};
|
bool lf_valid_filename{true};
|
||||||
std::optional<ghc::filesystem::path> lf_actual_path;
|
std::optional<std::filesystem::path> lf_actual_path;
|
||||||
std::string lf_basename;
|
std::string lf_basename;
|
||||||
std::string lf_content_id;
|
std::string lf_content_id;
|
||||||
struct stat lf_stat {};
|
struct stat lf_stat {};
|
||||||
|
@ -35,6 +35,8 @@
|
|||||||
#include <chrono>
|
#include <chrono>
|
||||||
#include <string>
|
#include <string>
|
||||||
|
|
||||||
|
#include <sys/stat.h>
|
||||||
|
|
||||||
#include "base/auto_fd.hh"
|
#include "base/auto_fd.hh"
|
||||||
#include "file_format.hh"
|
#include "file_format.hh"
|
||||||
#include "piper.looper.hh"
|
#include "piper.looper.hh"
|
||||||
|
@ -714,7 +714,7 @@ md2attr_line::to_attr_line(const pugi::xml_node& doc)
|
|||||||
if (img_alt) {
|
if (img_alt) {
|
||||||
link_label = img_alt.value();
|
link_label = img_alt.value();
|
||||||
} else if (img_src) {
|
} else if (img_src) {
|
||||||
link_label = ghc::filesystem::path(img_src.value())
|
link_label = std::filesystem::path(img_src.value())
|
||||||
.filename()
|
.filename()
|
||||||
.string();
|
.string();
|
||||||
} else {
|
} else {
|
||||||
@ -726,14 +726,14 @@ md2attr_line::to_attr_line(const pugi::xml_node& doc)
|
|||||||
if (is_url(src_value)) {
|
if (is_url(src_value)) {
|
||||||
src_href = src_value;
|
src_href = src_value;
|
||||||
} else {
|
} else {
|
||||||
auto src_path = ghc::filesystem::path(src_value);
|
auto src_path = std::filesystem::path(src_value);
|
||||||
std::error_code ec;
|
std::error_code ec;
|
||||||
|
|
||||||
if (src_path.is_relative() && this->ml_source_path) {
|
if (src_path.is_relative() && this->ml_source_path) {
|
||||||
src_path = this->ml_source_path.value().parent_path()
|
src_path = this->ml_source_path.value().parent_path()
|
||||||
/ src_path;
|
/ src_path;
|
||||||
}
|
}
|
||||||
auto canon_path = ghc::filesystem::canonical(src_path, ec);
|
auto canon_path = std::filesystem::canonical(src_path, ec);
|
||||||
if (!ec) {
|
if (!ec) {
|
||||||
src_path = canon_path;
|
src_path = canon_path;
|
||||||
}
|
}
|
||||||
@ -1074,7 +1074,7 @@ md2attr_line::append_url_footnote(std::string href_str)
|
|||||||
last_block.append(to_superscript(this->ml_footnotes.size() + 1));
|
last_block.append(to_superscript(this->ml_footnotes.size() + 1));
|
||||||
this->ml_last_superscript_index = last_block.length();
|
this->ml_last_superscript_index = last_block.length();
|
||||||
if (this->ml_source_path && href_str.find(':') == std::string::npos) {
|
if (this->ml_source_path && href_str.find(':') == std::string::npos) {
|
||||||
auto link_path = ghc::filesystem::absolute(
|
auto link_path = std::filesystem::absolute(
|
||||||
this->ml_source_path.value().parent_path() / href_str);
|
this->ml_source_path.value().parent_path() / href_str);
|
||||||
|
|
||||||
href_str = fmt::format(FMT_STRING("file://{}"), link_path.string());
|
href_str = fmt::format(FMT_STRING("file://{}"), link_path.string());
|
||||||
|
@ -31,7 +31,7 @@
|
|||||||
#define lnav_md2attr_line_hh
|
#define lnav_md2attr_line_hh
|
||||||
|
|
||||||
#include "base/attr_line.hh"
|
#include "base/attr_line.hh"
|
||||||
#include "ghc/filesystem.hpp"
|
#include <filesystem>
|
||||||
#include "md4cpp.hh"
|
#include "md4cpp.hh"
|
||||||
|
|
||||||
namespace pugi {
|
namespace pugi {
|
||||||
@ -42,7 +42,7 @@ class md2attr_line : public md4cpp::typed_event_handler<attr_line_t> {
|
|||||||
public:
|
public:
|
||||||
md2attr_line() { this->ml_blocks.resize(1); }
|
md2attr_line() { this->ml_blocks.resize(1); }
|
||||||
|
|
||||||
md2attr_line& with_source_path(std::optional<ghc::filesystem::path> path)
|
md2attr_line& with_source_path(std::optional<std::filesystem::path> path)
|
||||||
{
|
{
|
||||||
this->ml_source_path = path;
|
this->ml_source_path = path;
|
||||||
return *this;
|
return *this;
|
||||||
@ -83,7 +83,7 @@ private:
|
|||||||
void flush_footnotes();
|
void flush_footnotes();
|
||||||
attr_line_t to_attr_line(const pugi::xml_node& doc);
|
attr_line_t to_attr_line(const pugi::xml_node& doc);
|
||||||
|
|
||||||
std::optional<ghc::filesystem::path> ml_source_path;
|
std::optional<std::filesystem::path> ml_source_path;
|
||||||
std::vector<attr_line_t> ml_blocks;
|
std::vector<attr_line_t> ml_blocks;
|
||||||
std::vector<list_block_t> ml_list_stack;
|
std::vector<list_block_t> ml_list_stack;
|
||||||
std::vector<table_t> ml_tables;
|
std::vector<table_t> ml_tables;
|
||||||
|
@ -189,7 +189,7 @@ environ_to_map()
|
|||||||
|
|
||||||
looper::
|
looper::
|
||||||
looper(std::string name, auto_fd stdout_fd, auto_fd stderr_fd, options opts)
|
looper(std::string name, auto_fd stdout_fd, auto_fd stderr_fd, options opts)
|
||||||
: l_name(std::move(name)), l_cwd(ghc::filesystem::current_path().string()),
|
: l_name(std::move(name)), l_cwd(std::filesystem::current_path().string()),
|
||||||
l_env(environ_to_map()), l_stdout(std::move(stdout_fd)),
|
l_env(environ_to_map()), l_stdout(std::move(stdout_fd)),
|
||||||
l_stderr(std::move(stderr_fd)), l_options(opts)
|
l_stderr(std::move(stderr_fd)), l_options(opts)
|
||||||
{
|
{
|
||||||
@ -202,8 +202,8 @@ looper(std::string name, auto_fd stdout_fd, auto_fd stderr_fd, options opts)
|
|||||||
hasher().update(getmstime()).update(l_name).to_string(),
|
hasher().update(getmstime()).update(l_name).to_string(),
|
||||||
count);
|
count);
|
||||||
count += 1;
|
count += 1;
|
||||||
} while (ghc::filesystem::exists(this->l_out_dir));
|
} while (std::filesystem::exists(this->l_out_dir));
|
||||||
ghc::filesystem::create_directories(this->l_out_dir);
|
std::filesystem::create_directories(this->l_out_dir);
|
||||||
this->l_future = std::async(std::launch::async, [this]() { this->loop(); });
|
this->l_future = std::async(std::launch::async, [this]() { this->loop(); });
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -638,7 +638,7 @@ looper::loop()
|
|||||||
/ fmt::format(FMT_STRING("out.{}.{}"),
|
/ fmt::format(FMT_STRING("out.{}.{}"),
|
||||||
os.os_hash_id,
|
os.os_hash_id,
|
||||||
rotate_count % cfg.c_rotations);
|
rotate_count % cfg.c_rotations);
|
||||||
ghc::filesystem::rename(tmp_path, out_path);
|
std::filesystem::rename(tmp_path, out_path);
|
||||||
}
|
}
|
||||||
|
|
||||||
ssize_t wrc;
|
ssize_t wrc;
|
||||||
@ -724,14 +724,15 @@ cleanup()
|
|||||||
{
|
{
|
||||||
(void) std::async(std::launch::async, []() {
|
(void) std::async(std::launch::async, []() {
|
||||||
const auto& cfg = injector::get<const config&>();
|
const auto& cfg = injector::get<const config&>();
|
||||||
auto now = std::chrono::system_clock::now();
|
auto now = std::filesystem::file_time_type{
|
||||||
|
std::chrono::system_clock::now().time_since_epoch()};
|
||||||
auto cache_path = storage_path();
|
auto cache_path = storage_path();
|
||||||
std::vector<ghc::filesystem::path> to_remove;
|
std::vector<std::filesystem::path> to_remove;
|
||||||
|
|
||||||
for (const auto& cache_subdir :
|
for (const auto& cache_subdir :
|
||||||
ghc::filesystem::directory_iterator(cache_path))
|
std::filesystem::directory_iterator(cache_path))
|
||||||
{
|
{
|
||||||
auto mtime = ghc::filesystem::last_write_time(cache_subdir.path());
|
auto mtime = std::filesystem::last_write_time(cache_subdir.path());
|
||||||
auto exp_time = mtime + cfg.c_ttl;
|
auto exp_time = mtime + cfg.c_ttl;
|
||||||
if (now < exp_time) {
|
if (now < exp_time) {
|
||||||
continue;
|
continue;
|
||||||
@ -740,9 +741,9 @@ cleanup()
|
|||||||
bool is_recent = false;
|
bool is_recent = false;
|
||||||
|
|
||||||
for (const auto& entry :
|
for (const auto& entry :
|
||||||
ghc::filesystem::directory_iterator(cache_subdir))
|
std::filesystem::directory_iterator(cache_subdir))
|
||||||
{
|
{
|
||||||
auto mtime = ghc::filesystem::last_write_time(entry.path());
|
auto mtime = std::filesystem::last_write_time(entry.path());
|
||||||
auto exp_time = mtime + cfg.c_ttl;
|
auto exp_time = mtime + cfg.c_ttl;
|
||||||
if (now < exp_time) {
|
if (now < exp_time) {
|
||||||
is_recent = true;
|
is_recent = true;
|
||||||
@ -756,7 +757,7 @@ cleanup()
|
|||||||
|
|
||||||
for (auto& entry : to_remove) {
|
for (auto& entry : to_remove) {
|
||||||
log_debug("removing piper directory: %s", entry.c_str());
|
log_debug("removing piper directory: %s", entry.c_str());
|
||||||
ghc::filesystem::remove_all(entry);
|
std::filesystem::remove_all(entry);
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
}
|
}
|
||||||
|
@ -37,7 +37,7 @@
|
|||||||
#include "base/auto_fd.hh"
|
#include "base/auto_fd.hh"
|
||||||
#include "base/piper.file.hh"
|
#include "base/piper.file.hh"
|
||||||
#include "base/result.h"
|
#include "base/result.h"
|
||||||
#include "ghc/filesystem.hpp"
|
#include <filesystem>
|
||||||
#include "safe/safe.h"
|
#include "safe/safe.h"
|
||||||
#include "yajlpp/yajlpp_def.hh"
|
#include "yajlpp/yajlpp_def.hh"
|
||||||
|
|
||||||
@ -79,9 +79,9 @@ public:
|
|||||||
|
|
||||||
std::string get_name() const { return this->l_name; }
|
std::string get_name() const { return this->l_name; }
|
||||||
|
|
||||||
ghc::filesystem::path get_out_dir() const { return this->l_out_dir; }
|
std::filesystem::path get_out_dir() const { return this->l_out_dir; }
|
||||||
|
|
||||||
ghc::filesystem::path get_out_pattern() const
|
std::filesystem::path get_out_pattern() const
|
||||||
{
|
{
|
||||||
return this->l_out_dir / "out.*";
|
return this->l_out_dir / "out.*";
|
||||||
}
|
}
|
||||||
@ -124,7 +124,7 @@ private:
|
|||||||
const std::string l_name;
|
const std::string l_name;
|
||||||
const std::string l_cwd;
|
const std::string l_cwd;
|
||||||
const std::map<std::string, std::string> l_env;
|
const std::map<std::string, std::string> l_env;
|
||||||
ghc::filesystem::path l_out_dir;
|
std::filesystem::path l_out_dir;
|
||||||
auto_fd l_stdout;
|
auto_fd l_stdout;
|
||||||
auto_fd l_stderr;
|
auto_fd l_stderr;
|
||||||
options l_options;
|
options l_options;
|
||||||
@ -144,12 +144,12 @@ public:
|
|||||||
|
|
||||||
std::string get_name() const { return this->h_looper->get_name(); }
|
std::string get_name() const { return this->h_looper->get_name(); }
|
||||||
|
|
||||||
ghc::filesystem::path get_out_dir() const
|
std::filesystem::path get_out_dir() const
|
||||||
{
|
{
|
||||||
return this->h_looper->get_out_dir();
|
return this->h_looper->get_out_dir();
|
||||||
}
|
}
|
||||||
|
|
||||||
ghc::filesystem::path get_out_pattern() const
|
std::filesystem::path get_out_pattern() const
|
||||||
{
|
{
|
||||||
return this->h_looper->get_out_pattern();
|
return this->h_looper->get_out_pattern();
|
||||||
}
|
}
|
||||||
|
@ -1015,7 +1015,7 @@ rl_callback_int(readline_curses* rc, bool is_alt)
|
|||||||
|
|
||||||
case ln_mode_t::EXEC: {
|
case ln_mode_t::EXEC: {
|
||||||
std::error_code errc;
|
std::error_code errc;
|
||||||
ghc::filesystem::create_directories(lnav::paths::workdir(), errc);
|
std::filesystem::create_directories(lnav::paths::workdir(), errc);
|
||||||
auto open_temp_res = lnav::filesystem::open_temp_file(
|
auto open_temp_res = lnav::filesystem::open_temp_file(
|
||||||
lnav::paths::workdir() / "exec.XXXXXX");
|
lnav::paths::workdir() / "exec.XXXXXX");
|
||||||
|
|
||||||
|
@ -35,6 +35,7 @@
|
|||||||
#include <stdlib.h>
|
#include <stdlib.h>
|
||||||
#include <string.h>
|
#include <string.h>
|
||||||
#include <sys/ioctl.h>
|
#include <sys/ioctl.h>
|
||||||
|
#include <sys/param.h>
|
||||||
#include <sys/socket.h>
|
#include <sys/socket.h>
|
||||||
#include <sys/wait.h>
|
#include <sys/wait.h>
|
||||||
#include <unistd.h>
|
#include <unistd.h>
|
||||||
@ -640,9 +641,10 @@ readline_context::command_complete(int count, int key)
|
|||||||
return rl_insert(count, key);
|
return rl_insert(count, key);
|
||||||
}
|
}
|
||||||
|
|
||||||
readline_context::readline_context(std::string name,
|
readline_context::
|
||||||
readline_context::command_map_t* commands,
|
readline_context(std::string name,
|
||||||
bool case_sensitive)
|
readline_context::command_map_t* commands,
|
||||||
|
bool case_sensitive)
|
||||||
: rc_name(std::move(name)), rc_case_sensitive(case_sensitive),
|
: rc_name(std::move(name)), rc_case_sensitive(case_sensitive),
|
||||||
rc_quote_chars("\"'"), rc_highlighter(nullptr)
|
rc_quote_chars("\"'"), rc_highlighter(nullptr)
|
||||||
{
|
{
|
||||||
@ -723,8 +725,8 @@ readline_context::save()
|
|||||||
hs = nullptr;
|
hs = nullptr;
|
||||||
}
|
}
|
||||||
|
|
||||||
readline_curses::readline_curses(
|
readline_curses::
|
||||||
std::shared_ptr<pollable_supervisor> supervisor)
|
readline_curses(std::shared_ptr<pollable_supervisor> supervisor)
|
||||||
: pollable(supervisor, pollable::category::interactive),
|
: pollable(supervisor, pollable::category::interactive),
|
||||||
rc_focus(noop_func{}), rc_change(noop_func{}), rc_perform(noop_func{}),
|
rc_focus(noop_func{}), rc_change(noop_func{}), rc_perform(noop_func{}),
|
||||||
rc_alt_perform(noop_func{}), rc_timeout(noop_func{}),
|
rc_alt_perform(noop_func{}), rc_timeout(noop_func{}),
|
||||||
@ -734,7 +736,8 @@ readline_curses::readline_curses(
|
|||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
|
||||||
readline_curses::~readline_curses()
|
readline_curses::~
|
||||||
|
readline_curses()
|
||||||
{
|
{
|
||||||
this->rc_pty[RCF_MASTER].reset();
|
this->rc_pty[RCF_MASTER].reset();
|
||||||
this->rc_command_pipe[RCF_MASTER].reset();
|
this->rc_command_pipe[RCF_MASTER].reset();
|
||||||
@ -849,16 +852,16 @@ readline_curses::start()
|
|||||||
throw error(errno);
|
throw error(errno);
|
||||||
}
|
}
|
||||||
|
|
||||||
auto slave_path = ghc::filesystem::path(slave_path_str);
|
auto slave_path = std::filesystem::path(slave_path_str);
|
||||||
std::error_code ec;
|
std::error_code ec;
|
||||||
if (!ghc::filesystem::exists(slave_path, ec)) {
|
if (!std::filesystem::exists(slave_path, ec)) {
|
||||||
log_warning("ptsname_r() result does not exist -- %s", slave_path_str);
|
log_warning("ptsname_r() result does not exist -- %s", slave_path_str);
|
||||||
#ifdef TIOCGPTN
|
#ifdef TIOCGPTN
|
||||||
int ptn = 0;
|
int ptn = 0;
|
||||||
if (ioctl(this->rc_pty[RCF_MASTER], TIOCGPTN, &ptn) == 0) {
|
if (ioctl(this->rc_pty[RCF_MASTER], TIOCGPTN, &ptn) == 0) {
|
||||||
snprintf(
|
snprintf(
|
||||||
slave_path_str, sizeof(slave_path_str), "/dev/ttyp%d", ptn);
|
slave_path_str, sizeof(slave_path_str), "/dev/ttyp%d", ptn);
|
||||||
slave_path = ghc::filesystem::path(slave_path_str);
|
slave_path = std::filesystem::path(slave_path_str);
|
||||||
log_warning("... trying %s", slave_path.c_str());
|
log_warning("... trying %s", slave_path.c_str());
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
@ -479,7 +479,7 @@ add_config_possibilities()
|
|||||||
visited.insert(named_cap.get_name().to_string());
|
visited.insert(named_cap.get_name().to_string());
|
||||||
}
|
}
|
||||||
|
|
||||||
ghc::filesystem::path path_obj(path);
|
std::filesystem::path path_obj(path);
|
||||||
rc->add_possibility(ln_mode_t::COMMAND,
|
rc->add_possibility(ln_mode_t::COMMAND,
|
||||||
named_cap.get_name().to_string(),
|
named_cap.get_name().to_string(),
|
||||||
path_obj.parent_path().filename().string());
|
path_obj.parent_path().filename().string());
|
||||||
|
@ -34,7 +34,7 @@
|
|||||||
#include "base/itertools.hh"
|
#include "base/itertools.hh"
|
||||||
#include "config.h"
|
#include "config.h"
|
||||||
#include "curl_looper.hh"
|
#include "curl_looper.hh"
|
||||||
#include "ghc/filesystem.hpp"
|
#include <filesystem>
|
||||||
#include "yajlpp/yajlpp_def.hh"
|
#include "yajlpp/yajlpp_def.hh"
|
||||||
|
|
||||||
namespace regex101 {
|
namespace regex101 {
|
||||||
@ -80,7 +80,7 @@ static const typed_json_path_container<upsert_response> RESPONSE_HANDLERS = {
|
|||||||
yajlpp::property_handler("version").for_field(&upsert_response::cr_version),
|
yajlpp::property_handler("version").for_field(&upsert_response::cr_version),
|
||||||
};
|
};
|
||||||
|
|
||||||
static const ghc::filesystem::path REGEX101_BASE_URL
|
static const std::filesystem::path REGEX101_BASE_URL
|
||||||
= "https://regex101.com/api/regex";
|
= "https://regex101.com/api/regex";
|
||||||
static const char* USER_AGENT = "lnav/" PACKAGE_VERSION;
|
static const char* USER_AGENT = "lnav/" PACKAGE_VERSION;
|
||||||
|
|
||||||
|
@ -47,7 +47,7 @@ static const std::set<std::string> SUPPORTED_FLAVORS = {
|
|||||||
"pcre2",
|
"pcre2",
|
||||||
};
|
};
|
||||||
|
|
||||||
Result<ghc::filesystem::path, lnav::console::user_message>
|
Result<std::filesystem::path, lnav::console::user_message>
|
||||||
regex101::import(const std::string& url,
|
regex101::import(const std::string& url,
|
||||||
const std::string& name,
|
const std::string& name,
|
||||||
const std::string& pat_name)
|
const std::string& pat_name)
|
||||||
@ -124,7 +124,7 @@ regex101::import(const std::string& url,
|
|||||||
auto format_path
|
auto format_path
|
||||||
= lnav::paths::dotlnav() / "formats" / "installed" / format_filename;
|
= lnav::paths::dotlnav() / "formats" / "installed" / format_filename;
|
||||||
|
|
||||||
if (ghc::filesystem::exists(format_path)) {
|
if (std::filesystem::exists(format_path)) {
|
||||||
return Err(lnav::console::user_message::error(
|
return Err(lnav::console::user_message::error(
|
||||||
attr_line_t("unable to import: ")
|
attr_line_t("unable to import: ")
|
||||||
.append(lnav::roles::file(url)))
|
.append(lnav::roles::file(url)))
|
||||||
@ -270,7 +270,7 @@ regex101::import(const std::string& url,
|
|||||||
return Ok(format_path);
|
return Ok(format_path);
|
||||||
}
|
}
|
||||||
|
|
||||||
ghc::filesystem::path
|
std::filesystem::path
|
||||||
regex101::patch_path(const external_log_format* format,
|
regex101::patch_path(const external_log_format* format,
|
||||||
const std::string& permalink)
|
const std::string& permalink)
|
||||||
{
|
{
|
||||||
@ -287,7 +287,7 @@ regex101::patch_path(const external_log_format* format,
|
|||||||
fmt::format(FMT_STRING("regex101-{}.json"), permalink));
|
fmt::format(FMT_STRING("regex101-{}.json"), permalink));
|
||||||
}
|
}
|
||||||
|
|
||||||
Result<ghc::filesystem::path, lnav::console::user_message>
|
Result<std::filesystem::path, lnav::console::user_message>
|
||||||
regex101::patch(const external_log_format* format,
|
regex101::patch(const external_log_format* format,
|
||||||
const std::string& pat_name,
|
const std::string& pat_name,
|
||||||
const regex101::client::entry& entry)
|
const regex101::client::entry& entry)
|
||||||
|
@ -33,21 +33,21 @@
|
|||||||
#include <map>
|
#include <map>
|
||||||
|
|
||||||
#include "base/lnav.console.hh"
|
#include "base/lnav.console.hh"
|
||||||
#include "ghc/filesystem.hpp"
|
#include <filesystem>
|
||||||
#include "log_format_ext.hh"
|
#include "log_format_ext.hh"
|
||||||
#include "regex101.client.hh"
|
#include "regex101.client.hh"
|
||||||
|
|
||||||
namespace regex101 {
|
namespace regex101 {
|
||||||
|
|
||||||
Result<ghc::filesystem::path, lnav::console::user_message> import(
|
Result<std::filesystem::path, lnav::console::user_message> import(
|
||||||
const std::string& url,
|
const std::string& url,
|
||||||
const std::string& name,
|
const std::string& name,
|
||||||
const std::string& pat_name);
|
const std::string& pat_name);
|
||||||
|
|
||||||
ghc::filesystem::path patch_path(const external_log_format* format,
|
std::filesystem::path patch_path(const external_log_format* format,
|
||||||
const std::string& permalink);
|
const std::string& permalink);
|
||||||
|
|
||||||
Result<ghc::filesystem::path, lnav::console::user_message> patch(
|
Result<std::filesystem::path, lnav::console::user_message> patch(
|
||||||
const external_log_format* format,
|
const external_log_format* format,
|
||||||
const std::string& pat_name,
|
const std::string& pat_name,
|
||||||
const regex101::client::entry& entry);
|
const regex101::client::entry& entry);
|
||||||
|
@ -113,14 +113,14 @@ struct from_sqlite<log_file_session_state> {
|
|||||||
namespace lnav {
|
namespace lnav {
|
||||||
namespace session {
|
namespace session {
|
||||||
|
|
||||||
static std::optional<ghc::filesystem::path>
|
static std::optional<std::filesystem::path>
|
||||||
find_container_dir(ghc::filesystem::path file_path)
|
find_container_dir(std::filesystem::path file_path)
|
||||||
{
|
{
|
||||||
if (!ghc::filesystem::exists(file_path)) {
|
if (!std::filesystem::exists(file_path)) {
|
||||||
return std::nullopt;
|
return std::nullopt;
|
||||||
}
|
}
|
||||||
|
|
||||||
std::optional<ghc::filesystem::path> dir_with_last_readme;
|
std::optional<std::filesystem::path> dir_with_last_readme;
|
||||||
|
|
||||||
while (file_path.has_parent_path()
|
while (file_path.has_parent_path()
|
||||||
&& file_path != file_path.root_directory())
|
&& file_path != file_path.root_directory())
|
||||||
@ -130,7 +130,7 @@ find_container_dir(ghc::filesystem::path file_path)
|
|||||||
std::error_code ec;
|
std::error_code ec;
|
||||||
|
|
||||||
for (const auto& entry :
|
for (const auto& entry :
|
||||||
ghc::filesystem::directory_iterator(parent, ec))
|
std::filesystem::directory_iterator(parent, ec))
|
||||||
{
|
{
|
||||||
if (!entry.is_regular_file()) {
|
if (!entry.is_regular_file()) {
|
||||||
continue;
|
continue;
|
||||||
@ -281,12 +281,12 @@ SELECT content_id, format, time_offset FROM lnav_file
|
|||||||
}
|
}
|
||||||
|
|
||||||
auto file_path_str = name_pair.first;
|
auto file_path_str = name_pair.first;
|
||||||
auto file_path = ghc::filesystem::path(file_path_str);
|
auto file_path = std::filesystem::path(file_path_str);
|
||||||
auto container_path_opt = find_container_dir(file_path);
|
auto container_path_opt = find_container_dir(file_path);
|
||||||
if (container_path_opt) {
|
if (container_path_opt) {
|
||||||
auto container_parent = container_path_opt.value().parent_path();
|
auto container_parent = container_path_opt.value().parent_path();
|
||||||
auto file_container_path
|
auto file_container_path
|
||||||
= ghc::filesystem::relative(file_path, container_parent)
|
= std::filesystem::relative(file_path, container_parent)
|
||||||
.string();
|
.string();
|
||||||
file_containers[container_parent.string()].push_back(
|
file_containers[container_parent.string()].push_back(
|
||||||
file_container_path);
|
file_container_path);
|
||||||
@ -474,7 +474,7 @@ SELECT content_id, format, time_offset FROM lnav_file
|
|||||||
}
|
}
|
||||||
auto container_parent
|
auto container_parent
|
||||||
= container_path_opt.value().parent_path();
|
= container_path_opt.value().parent_path();
|
||||||
auto file_container_path = ghc::filesystem::relative(
|
auto file_container_path = std::filesystem::relative(
|
||||||
ld->get_file_ptr()->get_path(), container_parent);
|
ld->get_file_ptr()->get_path(), container_parent);
|
||||||
fmt::print(file,
|
fmt::print(file,
|
||||||
FMT_STRING(":hide-file */{}\n"),
|
FMT_STRING(":hide-file */{}\n"),
|
||||||
|
@ -37,7 +37,7 @@
|
|||||||
#include "base/fs_util.hh"
|
#include "base/fs_util.hh"
|
||||||
#include "base/lnav_log.hh"
|
#include "base/lnav_log.hh"
|
||||||
#include "config.h"
|
#include "config.h"
|
||||||
#include "ghc/filesystem.hpp"
|
#include <filesystem>
|
||||||
#include "lnav.hh"
|
#include "lnav.hh"
|
||||||
#include "vtab_module.hh"
|
#include "vtab_module.hh"
|
||||||
|
|
||||||
@ -49,7 +49,7 @@ struct static_file_vtab {
|
|||||||
};
|
};
|
||||||
|
|
||||||
struct static_file_info {
|
struct static_file_info {
|
||||||
ghc::filesystem::path sfi_path;
|
std::filesystem::path sfi_path;
|
||||||
};
|
};
|
||||||
|
|
||||||
struct sf_vtab_cursor {
|
struct sf_vtab_cursor {
|
||||||
@ -124,13 +124,13 @@ sfvt_destroy(sqlite3_vtab* p_vt)
|
|||||||
static int sfvt_next(sqlite3_vtab_cursor* cur);
|
static int sfvt_next(sqlite3_vtab_cursor* cur);
|
||||||
|
|
||||||
static void
|
static void
|
||||||
find_static_files(sf_vtab_cursor* p_cur, const ghc::filesystem::path& dir)
|
find_static_files(sf_vtab_cursor* p_cur, const std::filesystem::path& dir)
|
||||||
{
|
{
|
||||||
auto& file_map = p_cur->vc_files;
|
auto& file_map = p_cur->vc_files;
|
||||||
std::error_code ec;
|
std::error_code ec;
|
||||||
|
|
||||||
for (const auto& format_dir_entry :
|
for (const auto& format_dir_entry :
|
||||||
ghc::filesystem::directory_iterator(dir, ec))
|
std::filesystem::directory_iterator(dir, ec))
|
||||||
{
|
{
|
||||||
if (!format_dir_entry.is_directory()) {
|
if (!format_dir_entry.is_directory()) {
|
||||||
continue;
|
continue;
|
||||||
@ -138,10 +138,10 @@ find_static_files(sf_vtab_cursor* p_cur, const ghc::filesystem::path& dir)
|
|||||||
auto format_static_files_dir = format_dir_entry.path() / "static-files";
|
auto format_static_files_dir = format_dir_entry.path() / "static-files";
|
||||||
log_debug("format static files: %s", format_static_files_dir.c_str());
|
log_debug("format static files: %s", format_static_files_dir.c_str());
|
||||||
for (const auto& static_file_entry :
|
for (const auto& static_file_entry :
|
||||||
ghc::filesystem::recursive_directory_iterator(
|
std::filesystem::recursive_directory_iterator(
|
||||||
format_static_files_dir, ec))
|
format_static_files_dir, ec))
|
||||||
{
|
{
|
||||||
auto rel_path = ghc::filesystem::relative(static_file_entry.path(),
|
auto rel_path = std::filesystem::relative(static_file_entry.path(),
|
||||||
format_static_files_dir);
|
format_static_files_dir);
|
||||||
|
|
||||||
file_map[rel_path.string()] = {static_file_entry.path()};
|
file_map[rel_path.string()] = {static_file_entry.path()};
|
||||||
|
@ -34,7 +34,7 @@
|
|||||||
#include "base/auto_fd.hh"
|
#include "base/auto_fd.hh"
|
||||||
#include "base/auto_pid.hh"
|
#include "base/auto_pid.hh"
|
||||||
#include "config.h"
|
#include "config.h"
|
||||||
#include "ghc/filesystem.hpp"
|
#include <filesystem>
|
||||||
#include "line_buffer.hh"
|
#include "line_buffer.hh"
|
||||||
#include "tailerpp.hh"
|
#include "tailerpp.hh"
|
||||||
|
|
||||||
@ -102,7 +102,7 @@ main(int argc, char* const* argv)
|
|||||||
err_pipe.after_fork(child.in());
|
err_pipe.after_fork(child.in());
|
||||||
|
|
||||||
if (child.in_child()) {
|
if (child.in_child()) {
|
||||||
auto this_exe = ghc::filesystem::path(argv[0]);
|
auto this_exe = std::filesystem::path(argv[0]);
|
||||||
auto exe_dir = this_exe.parent_path();
|
auto exe_dir = this_exe.parent_path();
|
||||||
auto tailer_exe = exe_dir / "tailer";
|
auto tailer_exe = exe_dir / "tailer";
|
||||||
|
|
||||||
@ -165,8 +165,8 @@ main(int argc, char* const* argv)
|
|||||||
pe.pe_path.c_str(),
|
pe.pe_path.c_str(),
|
||||||
pe.pe_msg.c_str());
|
pe.pe_msg.c_str());
|
||||||
|
|
||||||
auto remote_path = ghc::filesystem::absolute(
|
auto remote_path = std::filesystem::absolute(
|
||||||
ghc::filesystem::path(pe.pe_path))
|
std::filesystem::path(pe.pe_path))
|
||||||
.relative_path();
|
.relative_path();
|
||||||
|
|
||||||
printf("removing %s\n", remote_path.c_str());
|
printf("removing %s\n", remote_path.c_str());
|
||||||
@ -177,8 +177,8 @@ main(int argc, char* const* argv)
|
|||||||
pob.pob_offset,
|
pob.pob_offset,
|
||||||
pob.pob_length);
|
pob.pob_length);
|
||||||
|
|
||||||
auto remote_path = ghc::filesystem::absolute(
|
auto remote_path = std::filesystem::absolute(
|
||||||
ghc::filesystem::path(pob.pob_path))
|
std::filesystem::path(pob.pob_path))
|
||||||
.relative_path();
|
.relative_path();
|
||||||
#if 0
|
#if 0
|
||||||
auto local_path = tmppath / remote_path;
|
auto local_path = tmppath / remote_path;
|
||||||
@ -196,7 +196,7 @@ main(int argc, char* const* argv)
|
|||||||
struct stat st;
|
struct stat st;
|
||||||
|
|
||||||
if (fstat(fd, &st) == -1 || !S_ISREG(st.st_mode)) {
|
if (fstat(fd, &st) == -1 || !S_ISREG(st.st_mode)) {
|
||||||
ghc::filesystem::remove_all(local_path);
|
std::filesystem::remove_all(local_path);
|
||||||
send_packet(to_child.get(),
|
send_packet(to_child.get(),
|
||||||
TPT_NEED_BLOCK,
|
TPT_NEED_BLOCK,
|
||||||
TPPT_STRING, pob.pob_path.c_str(),
|
TPPT_STRING, pob.pob_path.c_str(),
|
||||||
@ -222,7 +222,7 @@ main(int argc, char* const* argv)
|
|||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
} else if (bytes_read == -1) {
|
} else if (bytes_read == -1) {
|
||||||
ghc::filesystem::remove_all(local_path);
|
std::filesystem::remove_all(local_path);
|
||||||
}
|
}
|
||||||
send_packet(to_child.get(),
|
send_packet(to_child.get(),
|
||||||
TPT_NEED_BLOCK,
|
TPT_NEED_BLOCK,
|
||||||
@ -234,11 +234,11 @@ main(int argc, char* const* argv)
|
|||||||
#if 0
|
#if 0
|
||||||
//printf("got a tail: %s %lld %ld\n", ptb.ptb_path.c_str(),
|
//printf("got a tail: %s %lld %ld\n", ptb.ptb_path.c_str(),
|
||||||
// ptb.ptb_offset, ptb.ptb_bits.size());
|
// ptb.ptb_offset, ptb.ptb_bits.size());
|
||||||
auto remote_path = ghc::filesystem::absolute(
|
auto remote_path = std::filesystem::absolute(
|
||||||
ghc::filesystem::path(ptb.ptb_path)).relative_path();
|
std::filesystem::path(ptb.ptb_path)).relative_path();
|
||||||
auto local_path = tmppath / remote_path;
|
auto local_path = tmppath / remote_path;
|
||||||
|
|
||||||
ghc::filesystem::create_directories(local_path.parent_path());
|
std::filesystem::create_directories(local_path.parent_path());
|
||||||
auto fd = auto_fd(
|
auto fd = auto_fd(
|
||||||
open(local_path.c_str(), O_WRONLY | O_APPEND | O_CREAT,
|
open(local_path.c_str(), O_WRONLY | O_APPEND | O_CREAT,
|
||||||
0600));
|
0600));
|
||||||
|
@ -448,18 +448,18 @@ tailer::looper::host_tailer::for_host(const std::string& netloc)
|
|||||||
std::move(err_pipe.read_end())));
|
std::move(err_pipe.read_end())));
|
||||||
}
|
}
|
||||||
|
|
||||||
static ghc::filesystem::path
|
static std::filesystem::path
|
||||||
remote_cache_path()
|
remote_cache_path()
|
||||||
{
|
{
|
||||||
return lnav::paths::workdir() / "remotes";
|
return lnav::paths::workdir() / "remotes";
|
||||||
}
|
}
|
||||||
|
|
||||||
ghc::filesystem::path
|
std::filesystem::path
|
||||||
tailer::looper::host_tailer::tmp_path()
|
tailer::looper::host_tailer::tmp_path()
|
||||||
{
|
{
|
||||||
auto local_path = remote_cache_path();
|
auto local_path = remote_cache_path();
|
||||||
|
|
||||||
ghc::filesystem::create_directories(local_path);
|
std::filesystem::create_directories(local_path);
|
||||||
auto_mem<char> resolved_path;
|
auto_mem<char> resolved_path;
|
||||||
|
|
||||||
resolved_path = realpath(local_path.c_str(), nullptr);
|
resolved_path = realpath(local_path.c_str(), nullptr);
|
||||||
@ -478,11 +478,12 @@ scrub_netloc(const std::string& netloc)
|
|||||||
return std::regex_replace(netloc, TO_SCRUB, "_");
|
return std::regex_replace(netloc, TO_SCRUB, "_");
|
||||||
}
|
}
|
||||||
|
|
||||||
tailer::looper::host_tailer::host_tailer(const std::string& netloc,
|
tailer::looper::host_tailer::
|
||||||
auto_pid<process_state::running> child,
|
host_tailer(const std::string& netloc,
|
||||||
auto_fd to_child,
|
auto_pid<process_state::running> child,
|
||||||
auto_fd from_child,
|
auto_fd to_child,
|
||||||
auto_fd err_from_child)
|
auto_fd from_child,
|
||||||
|
auto_fd err_from_child)
|
||||||
: isc::service<host_tailer>(netloc), ht_netloc(netloc),
|
: isc::service<host_tailer>(netloc), ht_netloc(netloc),
|
||||||
ht_local_path(tmp_path() / scrub_netloc(netloc)),
|
ht_local_path(tmp_path() / scrub_netloc(netloc)),
|
||||||
ht_error_reader([netloc,
|
ht_error_reader([netloc,
|
||||||
@ -578,9 +579,9 @@ tailer::looper::host_tailer::loop_body()
|
|||||||
|
|
||||||
this->ht_cycle_count += 1;
|
this->ht_cycle_count += 1;
|
||||||
if (this->ht_cycle_count % TOUCH_FREQ == 0) {
|
if (this->ht_cycle_count % TOUCH_FREQ == 0) {
|
||||||
auto now
|
auto now = std::filesystem::file_time_type{
|
||||||
= ghc::filesystem::file_time_type{std::chrono::system_clock::now()};
|
std::chrono::system_clock::now().time_since_epoch()};
|
||||||
ghc::filesystem::last_write_time(this->ht_local_path, now);
|
std::filesystem::last_write_time(this->ht_local_path, now);
|
||||||
}
|
}
|
||||||
|
|
||||||
auto& conn = this->ht_state.get<connected>();
|
auto& conn = this->ht_state.get<connected>();
|
||||||
@ -648,14 +649,14 @@ tailer::looper::host_tailer::loop_body()
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
auto remote_path = ghc::filesystem::absolute(
|
auto remote_path = std::filesystem::absolute(
|
||||||
ghc::filesystem::path(pe.pe_path))
|
std::filesystem::path(pe.pe_path))
|
||||||
.relative_path();
|
.relative_path();
|
||||||
auto local_path = this->ht_local_path / remote_path;
|
auto local_path = this->ht_local_path / remote_path;
|
||||||
|
|
||||||
log_debug("removing %s", local_path.c_str());
|
log_debug("removing %s", local_path.c_str());
|
||||||
this->ht_active_files.erase(local_path);
|
this->ht_active_files.erase(local_path);
|
||||||
ghc::filesystem::remove_all(local_path);
|
std::filesystem::remove_all(local_path);
|
||||||
|
|
||||||
if (conn.c_desired_paths.empty() && conn.c_child_paths.empty())
|
if (conn.c_desired_paths.empty() && conn.c_child_paths.empty())
|
||||||
{
|
{
|
||||||
@ -706,8 +707,8 @@ tailer::looper::host_tailer::loop_body()
|
|||||||
update_tailer_description(
|
update_tailer_description(
|
||||||
this->ht_netloc, conn.c_desired_paths, this->ht_uname);
|
this->ht_netloc, conn.c_desired_paths, this->ht_uname);
|
||||||
|
|
||||||
auto remote_path = ghc::filesystem::absolute(
|
auto remote_path = std::filesystem::absolute(
|
||||||
ghc::filesystem::path(pob.pob_path))
|
std::filesystem::path(pob.pob_path))
|
||||||
.relative_path();
|
.relative_path();
|
||||||
auto local_path = this->ht_local_path / remote_path;
|
auto local_path = this->ht_local_path / remote_path;
|
||||||
auto open_res
|
auto open_res
|
||||||
@ -769,7 +770,7 @@ tailer::looper::host_tailer::loop_body()
|
|||||||
|
|
||||||
if (fstat(fd, &st) == -1 || !S_ISREG(st.st_mode)) {
|
if (fstat(fd, &st) == -1 || !S_ISREG(st.st_mode)) {
|
||||||
log_debug("path changed, sending need block");
|
log_debug("path changed, sending need block");
|
||||||
ghc::filesystem::remove_all(local_path);
|
std::filesystem::remove_all(local_path);
|
||||||
send_packet(conn.ht_to_child.get(),
|
send_packet(conn.ht_to_child.get(),
|
||||||
TPT_NEED_BLOCK,
|
TPT_NEED_BLOCK,
|
||||||
TPPT_STRING,
|
TPPT_STRING,
|
||||||
@ -808,7 +809,7 @@ tailer::looper::host_tailer::loop_body()
|
|||||||
log_debug(
|
log_debug(
|
||||||
"unable to read file, sending need block -- %s",
|
"unable to read file, sending need block -- %s",
|
||||||
strerror(errno));
|
strerror(errno));
|
||||||
ghc::filesystem::remove_all(local_path);
|
std::filesystem::remove_all(local_path);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
if (bytes_read == 0) {
|
if (bytes_read == 0) {
|
||||||
@ -847,8 +848,8 @@ tailer::looper::host_tailer::loop_body()
|
|||||||
return std::move(this->ht_state);
|
return std::move(this->ht_state);
|
||||||
},
|
},
|
||||||
[&](const tailer::packet_tail_block& ptb) {
|
[&](const tailer::packet_tail_block& ptb) {
|
||||||
auto remote_path = ghc::filesystem::absolute(
|
auto remote_path = std::filesystem::absolute(
|
||||||
ghc::filesystem::path(ptb.ptb_path))
|
std::filesystem::path(ptb.ptb_path))
|
||||||
.relative_path();
|
.relative_path();
|
||||||
auto local_path = this->ht_local_path / remote_path;
|
auto local_path = this->ht_local_path / remote_path;
|
||||||
|
|
||||||
@ -856,7 +857,7 @@ tailer::looper::host_tailer::loop_body()
|
|||||||
ptb.ptb_offset,
|
ptb.ptb_offset,
|
||||||
ptb.ptb_bits.size(),
|
ptb.ptb_bits.size(),
|
||||||
local_path.c_str());
|
local_path.c_str());
|
||||||
ghc::filesystem::create_directories(local_path.parent_path());
|
std::filesystem::create_directories(local_path.parent_path());
|
||||||
auto create_res = lnav::filesystem::create_file(
|
auto create_res = lnav::filesystem::create_file(
|
||||||
local_path, O_WRONLY | O_APPEND | O_CREAT, 0600);
|
local_path, O_WRONLY | O_APPEND | O_CREAT, 0600);
|
||||||
|
|
||||||
@ -869,10 +870,10 @@ tailer::looper::host_tailer::loop_body()
|
|||||||
ptb.ptb_bits.data(),
|
ptb.ptb_bits.data(),
|
||||||
ptb.ptb_bits.size(),
|
ptb.ptb_bits.size(),
|
||||||
ptb.ptb_offset);
|
ptb.ptb_offset);
|
||||||
auto mtime = ghc::filesystem::file_time_type{
|
auto mtime = std::filesystem::file_time_type{
|
||||||
std::chrono::seconds{ptb.ptb_mtime}};
|
std::chrono::seconds{ptb.ptb_mtime}};
|
||||||
// XXX This isn't atomic with the write...
|
// XXX This isn't atomic with the write...
|
||||||
ghc::filesystem::last_write_time(local_path, mtime);
|
std::filesystem::last_write_time(local_path, mtime);
|
||||||
}
|
}
|
||||||
return std::move(this->ht_state);
|
return std::move(this->ht_state);
|
||||||
},
|
},
|
||||||
@ -935,11 +936,11 @@ tailer::looper::host_tailer::loop_body()
|
|||||||
return std::move(this->ht_state);
|
return std::move(this->ht_state);
|
||||||
},
|
},
|
||||||
[&](const tailer::packet_link& pl) {
|
[&](const tailer::packet_link& pl) {
|
||||||
auto remote_path = ghc::filesystem::absolute(
|
auto remote_path = std::filesystem::absolute(
|
||||||
ghc::filesystem::path(pl.pl_path))
|
std::filesystem::path(pl.pl_path))
|
||||||
.relative_path();
|
.relative_path();
|
||||||
auto local_path = this->ht_local_path / remote_path;
|
auto local_path = this->ht_local_path / remote_path;
|
||||||
auto remote_link_path = ghc::filesystem::path(pl.pl_link_value);
|
auto remote_link_path = std::filesystem::path(pl.pl_link_value);
|
||||||
std::string link_path;
|
std::string link_path;
|
||||||
|
|
||||||
if (remote_link_path.is_absolute()) {
|
if (remote_link_path.is_absolute()) {
|
||||||
@ -954,8 +955,8 @@ tailer::looper::host_tailer::loop_body()
|
|||||||
log_debug("symlinking %s -> %s",
|
log_debug("symlinking %s -> %s",
|
||||||
local_path.c_str(),
|
local_path.c_str(),
|
||||||
link_path.c_str());
|
link_path.c_str());
|
||||||
ghc::filesystem::create_directories(local_path.parent_path());
|
std::filesystem::create_directories(local_path.parent_path());
|
||||||
ghc::filesystem::remove_all(local_path);
|
std::filesystem::remove_all(local_path);
|
||||||
if (symlink(link_path.c_str(), local_path.c_str()) < 0) {
|
if (symlink(link_path.c_str(), local_path.c_str()) < 0) {
|
||||||
log_error("symlink failed: %s", strerror(errno));
|
log_error("symlink failed: %s", strerror(errno));
|
||||||
}
|
}
|
||||||
@ -1169,16 +1170,17 @@ void
|
|||||||
tailer::cleanup_cache()
|
tailer::cleanup_cache()
|
||||||
{
|
{
|
||||||
(void) std::async(std::launch::async, []() {
|
(void) std::async(std::launch::async, []() {
|
||||||
auto now = std::chrono::system_clock::now();
|
auto now = std::filesystem::file_time_type{
|
||||||
|
std::chrono::system_clock::now().time_since_epoch()};
|
||||||
auto cache_path = remote_cache_path();
|
auto cache_path = remote_cache_path();
|
||||||
const auto& cfg = injector::get<const config&>();
|
const auto& cfg = injector::get<const config&>();
|
||||||
std::vector<ghc::filesystem::path> to_remove;
|
std::vector<std::filesystem::path> to_remove;
|
||||||
|
|
||||||
log_debug("cache-ttl %d", cfg.c_cache_ttl.count());
|
log_debug("cache-ttl %d", cfg.c_cache_ttl.count());
|
||||||
for (const auto& entry :
|
for (const auto& entry :
|
||||||
ghc::filesystem::directory_iterator(cache_path))
|
std::filesystem::directory_iterator(cache_path))
|
||||||
{
|
{
|
||||||
auto mtime = ghc::filesystem::last_write_time(entry.path());
|
auto mtime = std::filesystem::last_write_time(entry.path());
|
||||||
auto exp_time = mtime + cfg.c_cache_ttl;
|
auto exp_time = mtime + cfg.c_cache_ttl;
|
||||||
if (now < exp_time) {
|
if (now < exp_time) {
|
||||||
continue;
|
continue;
|
||||||
@ -1189,7 +1191,7 @@ tailer::cleanup_cache()
|
|||||||
|
|
||||||
for (auto& entry : to_remove) {
|
for (auto& entry : to_remove) {
|
||||||
log_debug("removing cached remote: %s", entry.c_str());
|
log_debug("removing cached remote: %s", entry.c_str());
|
||||||
ghc::filesystem::remove_all(entry);
|
std::filesystem::remove_all(entry);
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
}
|
}
|
||||||
|
@ -38,7 +38,7 @@
|
|||||||
#include "base/auto_pid.hh"
|
#include "base/auto_pid.hh"
|
||||||
#include "base/isc.hh"
|
#include "base/isc.hh"
|
||||||
#include "base/network.tcp.hh"
|
#include "base/network.tcp.hh"
|
||||||
#include "ghc/filesystem.hpp"
|
#include <filesystem>
|
||||||
#include "mapbox/variant.hpp"
|
#include "mapbox/variant.hpp"
|
||||||
|
|
||||||
namespace tailer {
|
namespace tailer {
|
||||||
@ -101,7 +101,7 @@ private:
|
|||||||
mstime_t current_time) const override;
|
mstime_t current_time) const override;
|
||||||
|
|
||||||
private:
|
private:
|
||||||
static ghc::filesystem::path tmp_path();
|
static std::filesystem::path tmp_path();
|
||||||
|
|
||||||
std::string get_display_path(const std::string& remote_path) const;
|
std::string get_display_path(const std::string& remote_path) const;
|
||||||
|
|
||||||
@ -125,8 +125,8 @@ private:
|
|||||||
|
|
||||||
const std::string ht_netloc;
|
const std::string ht_netloc;
|
||||||
std::string ht_uname;
|
std::string ht_uname;
|
||||||
const ghc::filesystem::path ht_local_path;
|
const std::filesystem::path ht_local_path;
|
||||||
std::set<ghc::filesystem::path> ht_active_files;
|
std::set<std::filesystem::path> ht_active_files;
|
||||||
std::vector<std::string> ht_error_queue;
|
std::vector<std::string> ht_error_queue;
|
||||||
std::thread ht_error_reader;
|
std::thread ht_error_reader;
|
||||||
state_v ht_state{disconnected()};
|
state_v ht_state{disconnected()};
|
||||||
|
@ -37,7 +37,7 @@
|
|||||||
#include "config.h"
|
#include "config.h"
|
||||||
#include "data_scanner.hh"
|
#include "data_scanner.hh"
|
||||||
#include "diseases-json.h"
|
#include "diseases-json.h"
|
||||||
#include "ghc/filesystem.hpp"
|
#include <filesystem>
|
||||||
#include "hasher.hh"
|
#include "hasher.hh"
|
||||||
#include "pcrepp/pcre2pp.hh"
|
#include "pcrepp/pcre2pp.hh"
|
||||||
#include "words-json.h"
|
#include "words-json.h"
|
||||||
@ -205,8 +205,8 @@ text_anonymizer::next(string_fragment line)
|
|||||||
cu, CURLUPART_PATH, url_part.out(), CURLU_URLDECODE)
|
cu, CURLUPART_PATH, url_part.out(), CURLU_URLDECODE)
|
||||||
== CURLUE_OK)
|
== CURLUE_OK)
|
||||||
{
|
{
|
||||||
ghc::filesystem::path url_path(url_part.in());
|
std::filesystem::path url_path(url_part.in());
|
||||||
ghc::filesystem::path anon_path;
|
std::filesystem::path anon_path;
|
||||||
|
|
||||||
for (const auto& comp : url_path) {
|
for (const auto& comp : url_path) {
|
||||||
if (comp == comp.root_path()) {
|
if (comp == comp.root_path()) {
|
||||||
@ -290,8 +290,8 @@ text_anonymizer::next(string_fragment line)
|
|||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
case DT_PATH: {
|
case DT_PATH: {
|
||||||
ghc::filesystem::path inp_path(tok_res->to_string());
|
std::filesystem::path inp_path(tok_res->to_string());
|
||||||
ghc::filesystem::path anon_path;
|
std::filesystem::path anon_path;
|
||||||
|
|
||||||
for (const auto& comp : inp_path) {
|
for (const auto& comp : inp_path) {
|
||||||
auto comp_str = comp.string();
|
auto comp_str = comp.string();
|
||||||
|
@ -40,16 +40,16 @@
|
|||||||
|
|
||||||
text_format_t
|
text_format_t
|
||||||
detect_text_format(string_fragment sf,
|
detect_text_format(string_fragment sf,
|
||||||
std::optional<ghc::filesystem::path> path)
|
std::optional<std::filesystem::path> path)
|
||||||
{
|
{
|
||||||
static const std::set<ghc::filesystem::path> FILTER_EXTS = {
|
static const std::set<std::filesystem::path> FILTER_EXTS = {
|
||||||
".bz2",
|
".bz2",
|
||||||
".gz",
|
".gz",
|
||||||
".lzma",
|
".lzma",
|
||||||
".xz",
|
".xz",
|
||||||
".zst",
|
".zst",
|
||||||
};
|
};
|
||||||
static const auto C_EXTS = std::set<ghc::filesystem::path>{
|
static const auto C_EXTS = std::set<std::filesystem::path>{
|
||||||
".h",
|
".h",
|
||||||
".hh",
|
".hh",
|
||||||
".hpp",
|
".hpp",
|
||||||
@ -58,17 +58,17 @@ detect_text_format(string_fragment sf,
|
|||||||
".cpp",
|
".cpp",
|
||||||
".tpp",
|
".tpp",
|
||||||
};
|
};
|
||||||
static const auto PY_EXT = ghc::filesystem::path(".py");
|
static const auto PY_EXT = std::filesystem::path(".py");
|
||||||
static const auto RS_EXT = ghc::filesystem::path(".rs");
|
static const auto RS_EXT = std::filesystem::path(".rs");
|
||||||
static const auto JAVA_EXT = ghc::filesystem::path(".java");
|
static const auto JAVA_EXT = std::filesystem::path(".java");
|
||||||
static const auto TOML_EXT = ghc::filesystem::path(".toml");
|
static const auto TOML_EXT = std::filesystem::path(".toml");
|
||||||
static const auto XML_EXT = ghc::filesystem::path(".xml");
|
static const auto XML_EXT = std::filesystem::path(".xml");
|
||||||
static const auto YAML_EXT = ghc::filesystem::path(".yaml");
|
static const auto YAML_EXT = std::filesystem::path(".yaml");
|
||||||
static const auto YML_EXT = ghc::filesystem::path(".yml");
|
static const auto YML_EXT = std::filesystem::path(".yml");
|
||||||
static const auto MAKEFILE_STEM = ghc::filesystem::path("Makefile");
|
static const auto MAKEFILE_STEM = std::filesystem::path("Makefile");
|
||||||
static const auto MD_EXT = ghc::filesystem::path(".md");
|
static const auto MD_EXT = std::filesystem::path(".md");
|
||||||
static const auto MARKDOWN_EXT = ghc::filesystem::path(".markdown");
|
static const auto MARKDOWN_EXT = std::filesystem::path(".markdown");
|
||||||
static const auto SH_EXT = ghc::filesystem::path(".sh");
|
static const auto SH_EXT = std::filesystem::path(".sh");
|
||||||
|
|
||||||
static const auto DIFF_MATCHERS = lnav::pcre2pp::code::from_const(
|
static const auto DIFF_MATCHERS = lnav::pcre2pp::code::from_const(
|
||||||
R"(^--- .*\n\+\+\+ .*\n)", PCRE2_MULTILINE);
|
R"(^--- .*\n\+\+\+ .*\n)", PCRE2_MULTILINE);
|
||||||
|
@ -38,7 +38,7 @@
|
|||||||
|
|
||||||
#include "base/intern_string.hh"
|
#include "base/intern_string.hh"
|
||||||
#include "fmt/format.h"
|
#include "fmt/format.h"
|
||||||
#include "ghc/filesystem.hpp"
|
#include <filesystem>
|
||||||
|
|
||||||
enum class text_format_t {
|
enum class text_format_t {
|
||||||
TF_UNKNOWN,
|
TF_UNKNOWN,
|
||||||
@ -131,7 +131,7 @@ struct formatter<text_format_t> : formatter<string_view> {
|
|||||||
* @return The detected format.
|
* @return The detected format.
|
||||||
*/
|
*/
|
||||||
text_format_t detect_text_format(string_fragment sf,
|
text_format_t detect_text_format(string_fragment sf,
|
||||||
std::optional<ghc::filesystem::path> path
|
std::optional<std::filesystem::path> path
|
||||||
= std::nullopt);
|
= std::nullopt);
|
||||||
|
|
||||||
struct text_format_meta_t {
|
struct text_format_meta_t {
|
||||||
|
@ -37,7 +37,7 @@
|
|||||||
#include <string>
|
#include <string>
|
||||||
#include <vector>
|
#include <vector>
|
||||||
|
|
||||||
#include "ghc/filesystem.hpp"
|
#include <filesystem>
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* A source of a path for the unique_path_generator.
|
* A source of a path for the unique_path_generator.
|
||||||
@ -51,26 +51,26 @@ public:
|
|||||||
this->ups_unique_path = path;
|
this->ups_unique_path = path;
|
||||||
}
|
}
|
||||||
|
|
||||||
const ghc::filesystem::path& get_unique_path() const
|
const std::filesystem::path& get_unique_path() const
|
||||||
{
|
{
|
||||||
return this->ups_unique_path;
|
return this->ups_unique_path;
|
||||||
}
|
}
|
||||||
|
|
||||||
virtual ghc::filesystem::path get_path() const = 0;
|
virtual std::filesystem::path get_path() const = 0;
|
||||||
|
|
||||||
const ghc::filesystem::path& get_path_prefix() const
|
const std::filesystem::path& get_path_prefix() const
|
||||||
{
|
{
|
||||||
return this->ups_prefix;
|
return this->ups_prefix;
|
||||||
}
|
}
|
||||||
|
|
||||||
void set_path_prefix(const ghc::filesystem::path& prefix)
|
void set_path_prefix(const std::filesystem::path& prefix)
|
||||||
{
|
{
|
||||||
this->ups_prefix = prefix;
|
this->ups_prefix = prefix;
|
||||||
}
|
}
|
||||||
|
|
||||||
private:
|
private:
|
||||||
ghc::filesystem::path ups_prefix;
|
std::filesystem::path ups_prefix;
|
||||||
ghc::filesystem::path ups_unique_path;
|
std::filesystem::path ups_unique_path;
|
||||||
};
|
};
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
@ -180,7 +180,7 @@ looper::open(std::string url)
|
|||||||
host_part_str = host_part;
|
host_part_str = host_part;
|
||||||
}
|
}
|
||||||
|
|
||||||
auto source_path = ghc::filesystem::path{
|
auto source_path = std::filesystem::path{
|
||||||
proto_iter->second.p_handler.pp_location.sl_source.get()};
|
proto_iter->second.p_handler.pp_location.sl_source.get()};
|
||||||
auto new_path = lnav::filesystem::build_path({
|
auto new_path = lnav::filesystem::build_path({
|
||||||
source_path.parent_path(),
|
source_path.parent_path(),
|
||||||
|
@ -45,7 +45,7 @@ public:
|
|||||||
url_loader(const std::string& url) : curl_request(url)
|
url_loader(const std::string& url) : curl_request(url)
|
||||||
{
|
{
|
||||||
std::error_code errc;
|
std::error_code errc;
|
||||||
ghc::filesystem::create_directories(lnav::paths::workdir(), errc);
|
std::filesystem::create_directories(lnav::paths::workdir(), errc);
|
||||||
auto tmp_res = lnav::filesystem::open_temp_file(lnav::paths::workdir()
|
auto tmp_res = lnav::filesystem::open_temp_file(lnav::paths::workdir()
|
||||||
/ "url.XXXXXX");
|
/ "url.XXXXXX");
|
||||||
if (tmp_res.isErr()) {
|
if (tmp_res.isErr()) {
|
||||||
@ -63,7 +63,7 @@ public:
|
|||||||
curl_easy_setopt(this->cr_handle, CURLOPT_BUFFERSIZE, 128L * 1024L);
|
curl_easy_setopt(this->cr_handle, CURLOPT_BUFFERSIZE, 128L * 1024L);
|
||||||
}
|
}
|
||||||
|
|
||||||
ghc::filesystem::path get_path() const { return this->ul_path; }
|
std::filesystem::path get_path() const { return this->ul_path; }
|
||||||
|
|
||||||
long complete(CURLcode result)
|
long complete(CURLcode result)
|
||||||
{
|
{
|
||||||
@ -144,7 +144,7 @@ private:
|
|||||||
return retval;
|
return retval;
|
||||||
}
|
}
|
||||||
|
|
||||||
ghc::filesystem::path ul_path;
|
std::filesystem::path ul_path;
|
||||||
auto_fd ul_fd;
|
auto_fd ul_fd;
|
||||||
off_t ul_resume_offset{0};
|
off_t ul_resume_offset{0};
|
||||||
};
|
};
|
||||||
|
@ -792,7 +792,7 @@ view_colors::to_attrs(const lnav_theme& lt,
|
|||||||
reporter(&sc.sc_color, lnav::console::user_message::warning(""));
|
reporter(&sc.sc_color, lnav::console::user_message::warning(""));
|
||||||
#endif
|
#endif
|
||||||
} else {
|
} else {
|
||||||
auto role_class_path = ghc::filesystem::path(pp_sc.pp_path.to_string());
|
auto role_class_path = std::filesystem::path(pp_sc.pp_path.to_string());
|
||||||
auto inner = role_class_path.filename().string();
|
auto inner = role_class_path.filename().string();
|
||||||
auto outer = role_class_path.parent_path().filename().string();
|
auto outer = role_class_path.parent_path().filename().string();
|
||||||
|
|
||||||
|
@ -36,7 +36,7 @@
|
|||||||
|
|
||||||
#include "config.h"
|
#include "config.h"
|
||||||
#include "fmt/format.h"
|
#include "fmt/format.h"
|
||||||
#include "ghc/filesystem.hpp"
|
#include <filesystem>
|
||||||
#include "yajl/api/yajl_parse.h"
|
#include "yajl/api/yajl_parse.h"
|
||||||
#include "yajlpp_def.hh"
|
#include "yajlpp_def.hh"
|
||||||
|
|
||||||
@ -1592,8 +1592,8 @@ dump_schema_to(const json_path_container& jpc, const char* internals_dir)
|
|||||||
{
|
{
|
||||||
yajlpp_gen genner;
|
yajlpp_gen genner;
|
||||||
yajlpp_gen_context ygc(genner, jpc);
|
yajlpp_gen_context ygc(genner, jpc);
|
||||||
auto internals_dir_path = ghc::filesystem::path(internals_dir);
|
auto internals_dir_path = std::filesystem::path(internals_dir);
|
||||||
auto schema_file_name = ghc::filesystem::path(jpc.jpc_schema_id).filename();
|
auto schema_file_name = std::filesystem::path(jpc.jpc_schema_id).filename();
|
||||||
auto schema_path = internals_dir_path / schema_file_name;
|
auto schema_path = internals_dir_path / schema_file_name;
|
||||||
auto file = std::unique_ptr<FILE, decltype(&fclose)>(
|
auto file = std::unique_ptr<FILE, decltype(&fclose)>(
|
||||||
fopen(schema_path.c_str(), "w+"), fclose);
|
fopen(schema_path.c_str(), "w+"), fclose);
|
||||||
|
@ -74,7 +74,7 @@ main(int argc, char* argv[])
|
|||||||
}
|
}
|
||||||
|
|
||||||
{
|
{
|
||||||
std::vector<ghc::filesystem::path> paths;
|
std::vector<std::filesystem::path> paths;
|
||||||
std::vector<lnav::console::user_message> errors;
|
std::vector<lnav::console::user_message> errors;
|
||||||
|
|
||||||
load_formats(paths, errors);
|
load_formats(paths, errors);
|
||||||
|
@ -42,7 +42,7 @@ main(int argc, char* argv[])
|
|||||||
fprintf(stderr, "error: expecting file to discover\n");
|
fprintf(stderr, "error: expecting file to discover\n");
|
||||||
retval = EXIT_FAILURE;
|
retval = EXIT_FAILURE;
|
||||||
} else {
|
} else {
|
||||||
const auto fn = ghc::filesystem::path(argv[1]);
|
const auto fn = std::filesystem::path(argv[1]);
|
||||||
auto read_res = lnav::filesystem::read_file(fn);
|
auto read_res = lnav::filesystem::read_file(fn);
|
||||||
if (read_res.isErr()) {
|
if (read_res.isErr()) {
|
||||||
fprintf(stderr,
|
fprintf(stderr,
|
||||||
|
@ -84,7 +84,7 @@ main(int argc, char* argv[])
|
|||||||
|
|
||||||
{
|
{
|
||||||
std::vector<lnav::console::user_message> errors;
|
std::vector<lnav::console::user_message> errors;
|
||||||
vector<ghc::filesystem::path> paths;
|
vector<std::filesystem::path> paths;
|
||||||
|
|
||||||
getenv_opt("test_dir") |
|
getenv_opt("test_dir") |
|
||||||
[&paths](auto value) { paths.template emplace_back(value); };
|
[&paths](auto value) { paths.template emplace_back(value); };
|
||||||
|
@ -210,11 +210,11 @@ TEST_CASE("ptime_roundtrip")
|
|||||||
|
|
||||||
class my_path_source : public unique_path_source {
|
class my_path_source : public unique_path_source {
|
||||||
public:
|
public:
|
||||||
explicit my_path_source(ghc::filesystem::path p) : mps_path(std::move(p)) {}
|
explicit my_path_source(std::filesystem::path p) : mps_path(std::move(p)) {}
|
||||||
|
|
||||||
ghc::filesystem::path get_path() const override { return this->mps_path; }
|
std::filesystem::path get_path() const override { return this->mps_path; }
|
||||||
|
|
||||||
ghc::filesystem::path mps_path;
|
std::filesystem::path mps_path;
|
||||||
};
|
};
|
||||||
|
|
||||||
TEST_CASE("unique_path")
|
TEST_CASE("unique_path")
|
||||||
|
@ -71,6 +71,7 @@
|
|||||||
#endif
|
#endif
|
||||||
|
|
||||||
#include <algorithm>
|
#include <algorithm>
|
||||||
|
#include <filesystem>
|
||||||
#include <map>
|
#include <map>
|
||||||
#include <queue>
|
#include <queue>
|
||||||
#include <sstream>
|
#include <sstream>
|
||||||
@ -81,7 +82,6 @@
|
|||||||
#include "base/auto_mem.hh"
|
#include "base/auto_mem.hh"
|
||||||
#include "base/string_util.hh"
|
#include "base/string_util.hh"
|
||||||
#include "fmt/format.h"
|
#include "fmt/format.h"
|
||||||
#include "ghc/filesystem.hpp"
|
|
||||||
#include "styling.hh"
|
#include "styling.hh"
|
||||||
#include "termios_guard.hh"
|
#include "termios_guard.hh"
|
||||||
#include "ww898/cp_utf8.hpp"
|
#include "ww898/cp_utf8.hpp"
|
||||||
@ -268,9 +268,9 @@ static struct {
|
|||||||
|
|
||||||
pid_t sd_child_pid{-1};
|
pid_t sd_child_pid{-1};
|
||||||
|
|
||||||
ghc::filesystem::path sd_actual_name;
|
std::filesystem::path sd_actual_name;
|
||||||
auto_mem<FILE> sd_from_child{fclose};
|
auto_mem<FILE> sd_from_child{fclose};
|
||||||
ghc::filesystem::path sd_expected_name;
|
std::filesystem::path sd_expected_name;
|
||||||
|
|
||||||
deque<struct command> sd_replay;
|
deque<struct command> sd_replay;
|
||||||
} scripty_data;
|
} scripty_data;
|
||||||
@ -1123,8 +1123,8 @@ main(int argc, char* argv[])
|
|||||||
scripty_data.sd_expected_name.c_str());
|
scripty_data.sd_expected_name.c_str());
|
||||||
|
|
||||||
auto options
|
auto options
|
||||||
= ghc::filesystem::copy_options::overwrite_existing;
|
= std::filesystem::copy_options::overwrite_existing;
|
||||||
ghc::filesystem::copy_file(scripty_data.sd_actual_name,
|
std::filesystem::copy_file(scripty_data.sd_actual_name,
|
||||||
scripty_data.sd_expected_name,
|
scripty_data.sd_expected_name,
|
||||||
options);
|
options);
|
||||||
} else {
|
} else {
|
||||||
|
@ -48,6 +48,7 @@ run_cap_test ${lnav_test} -m -I ${test_dir} config blame
|
|||||||
|
|
||||||
export TMPDIR="piper-tmp"
|
export TMPDIR="piper-tmp"
|
||||||
rm -rf ./piper-tmp
|
rm -rf ./piper-tmp
|
||||||
|
mkdir piper-tmp
|
||||||
run_cap_test ${lnav_test} -n -e 'echo hi'
|
run_cap_test ${lnav_test} -n -e 'echo hi'
|
||||||
|
|
||||||
run_cap_test ${lnav_test} -m piper list
|
run_cap_test ${lnav_test} -m piper list
|
||||||
|
@ -64,7 +64,7 @@ main(int argc, char* argv[])
|
|||||||
setenv("HOME", "/", 1);
|
setenv("HOME", "/", 1);
|
||||||
|
|
||||||
std::vector<lnav::console::user_message> errors;
|
std::vector<lnav::console::user_message> errors;
|
||||||
std::vector<ghc::filesystem::path> paths;
|
std::vector<std::filesystem::path> paths;
|
||||||
|
|
||||||
load_config(paths, errors);
|
load_config(paths, errors);
|
||||||
|
|
||||||
|
Loading…
Reference in New Issue
Block a user