output_directory.hpp

Go to the documentation of this file.

//This file is part of Bertini 2.
//
//output_directory.hpp is free software: you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation, either version 3 of the License, or
//(at your option) any later version.
//
//output_directory.hpp is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with output_directory.hpp.  If not, see <http://www.gnu.org/licenses/>.
//
// Copyright(C) Bertini2 Development Team
//
// See <http://www.gnu.org/licenses/> for a copy of the license,
// as well as COPYING.  Bertini2 is provided with permitted
// additional terms in the b2/licenses/ directory.

 
#pragma once
 
#include <cstddef>
#include <cstdint>
#include <filesystem>
#include <fstream>
#include <map>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <vector>
 
#include <boost/json.hpp>
 
#include "bertini2/detail/sha256.hpp"
 
namespace bertini {
namespace records {

constexpr char RecordSchemaVersion[] = "b2rec/1";

class OutputDirectory
{
public:
    explicit OutputDirectory(std::filesystem::path root);

    static std::shared_ptr<OutputDirectory> Shared(std::filesystem::path const& root);

    std::filesystem::path const& Root() const { return root_; }
 
    // ---- definitions (content-addressed, grouped by kind) ----

    std::string PutDefinition(std::string const& content, std::string const& kind,
                              std::optional<std::string> external_id = std::nullopt,
                              std::string const& label = {});

    std::string GetDefinition(std::string const& id) const;

    bool HasDefinition(std::string const& id) const;
 
    // ---- history (append-only JSONL) ----

    void Append(boost::json::object const& record);

    void Annotate(std::string const& run_id, std::int64_t index,
                  std::string const& key, boost::json::value const& value);

    std::vector<boost::json::object> Scan() const;
 
    // ---- results (per-run append-only JSONL payload files; truth) ----

    void EnsureResultsFile(std::string const& run_id, boost::json::object const& header);

    void AppendResult(std::string const& run_id, boost::json::object const& record);

    std::vector<boost::json::object> ResultsOf(std::string const& run_id) const;
 
    // ---- derived views (rebuildable at will) ----

    void RefreshIndex() const;

    std::string Describe() const;
 
private:
    std::filesystem::path DefinitionPath(std::string const& kind, std::string const& id,
                                         std::string const& label) const;
    std::optional<std::filesystem::path> FindDefinition(std::string const& id) const;
    std::filesystem::path ResultsPath(std::string const& run_id) const;
    void EnsureSessionFile();

    void ReleaseFiles();
 
    std::filesystem::path root_;        
    long pid_;                          
    std::ofstream session_;             
    std::filesystem::path session_path_; 
    std::mutex append_mutex_;           
    std::map<std::string, std::ofstream> results_streams_;  

    static constexpr std::size_t kMaxOpenResultsFiles = 16;
};

std::string SystemEncodingAsJson(std::string const& encoding_text,
                                 std::string const& digest_hex,
                                 boost::json::object const& parts);

std::string TimeStampNow();

std::optional<std::string> AmbientRecordsPath();
 
} // namespace records
} // namespace bertini