Commit b068d852 authored by Marc Vef's avatar Marc Vef
Browse files

Workworkworkworkwork. write metadata to disk, read 50%. TODO serialize.

parent 69c83d9d

fs/src/main.cpp

+26 −13
Original line number Diff line number Diff line 
#include "main.h"

#include "metadata.h"

#include "metadata_ops.h"

#include "fuse_ops.h"



#include <string.h>



static struct fuse_operations adafs_ops;



using namespace std;



std::shared_ptr<Metadata> md;

//std::shared_ptr<Metadata> md;



int adafs_getattr(const char *path, struct stat *attr){



    auto fpath = util::adafs_fullpath("meta/inodes"s);

    auto md = make_shared<Metadata>();

    md->setMode(S_IFDIR | 0755);

    read_all_metadata(*md, 1, *fpath);

    ADAFS_DATA->logger->info("ctime: {}", md->getAtime_());

    ADAFS_DATA->logger->info("inode: {}", md->getInode_no());

    if (strcmp(path, "/") == 0) {

        attr->st_ino = md->getInode_no();

        attr->st_mode = md->getMode();
@@ -18,7 +23,7 @@ int adafs_getattr(const char *path, struct stat *attr){ 
        attr->st_uid = md->getUid();

        attr->st_gid = md->getGid();

        attr->st_size = md->getSize();

        attr->st_blksize = 4096;

        attr->st_blksize = ADAFS_DATA->blocksize;

        attr->st_blocks = md->getBlocks();

        attr->st_atim.tv_sec = md->getAtime_();

        attr->st_mtim.tv_sec = md->getMtime_();
@@ -37,24 +42,32 @@ int adafs_getattr(const char *path, struct stat *attr){ 


void *adafs_init(struct fuse_conn_info *conn) {



    ADAFS_DATA->logger->info("init function"s);

    ADAFS_DATA->logger->info("uid_: {}", fuse_get_context()->uid);

    ADAFS_DATA->logger->info("gid_: {}", fuse_get_context()->gid);

    ADAFS_DATA->logger->info("pid: {0:d}", fuse_get_context()->pid);

    ADAFS_DATA->logger->info("rootdir: {}", ((struct adafs_data*)fuse_get_context()->private_data)->rootdir);

//    ADAFS_DATA->logger->info("init function"s);

//    ADAFS_DATA->logger->info("uid_: {}", fuse_get_context()->uid);

//    ADAFS_DATA->logger->info("gid_: {}", fuse_get_context()->gid);

//    ADAFS_DATA->logger->info("pid: {0:d}", fuse_get_context()->pid);

//    ADAFS_DATA->logger->info("rootdir: {}", ((struct adafs_data*)fuse_get_context()->private_data)->rootdir);

    //Initialize directory structure for metadata.

    boost::filesystem::create_directories(ADAFS_DATA->rootdir + "/meta/dentries"s);

    boost::filesystem::create_directories(ADAFS_DATA->rootdir + "/meta/inodes"s);

    boost::filesystem::create_directories(ADAFS_DATA->rootdir + "/data/chunks"s);

    //Init file system configuration

    ADAFS_DATA->blocksize = 4096;





    //Init metadata

//    if (get_metadata("/") == -ENOENT) {

//        md = make_shared<Metadata>(S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO);

        md = make_shared<Metadata>(S_IFDIR | 0755);

//        auto md = make_shared<Metadata>(S_IFDIR | 0755);

//    }

//    auto s = util::adafs_fullpath("meta/inodes");

//



//    write_all_metadata(*md, *s);



    ADAFS_DATA->logger->info("Survived creating Metadata object"s);

    ADAFS_DATA->logger->flush();





    return ADAFS_DATA;

}
@@ -77,7 +90,7 @@ int main(int argc, char *argv[]) { 
    init_adafs_ops(&adafs_ops);



    // create the adafs_data object (struct)

    auto a_data = make_unique<adafs_data>();

    auto a_data = make_shared<adafs_data>();

    //set the logger and initialize it with spdlog

    a_data->logger = spdlog::basic_logger_mt("basic_logger", "adafs.log");

    //extract the rootdir from argv and put it into rootdir of adafs_data

fs/src/main.h

+3 −1
Original line number Diff line number Diff line
@@ -16,18 +16,20 @@ 
#include <boost/filesystem.hpp>



#include "spdlog/spdlog.h"

#include "metadata.h"





struct adafs_data {

    std::string                             rootdir;

    std::shared_ptr<spdlog::logger>         logger;

    std::int64_t                            inode_count;

    std::mutex                              inode_mutex;

    int32_t                                 blocksize;

};



#define ADAFS_DATA ((struct adafs_data*) fuse_get_context()->private_data)



namespace util {

    std::unique_ptr<std::string> adafs_fullpath(const std::string& path);

    int reset_inode_no(void);

    ino_t generate_inode_no(void);

}

fs/src/metadata.cpp

+12 −2
Original line number Diff line number Diff line
@@ -89,8 +89,18 @@ void Metadata::setBlocks(uint32_t blocks) { 
}



//--------------------------------------------

// By default create a simple file

Metadata::Metadata() : Metadata(S_IFREG | 0755) {}

// By default create an empty metadata object

//Metadata::Metadata() : Metadata(S_IFREG | 0755) {}

Metadata::Metadata() : atime_(),

                       mtime_(),

                       ctime_(),

                       uid_(),

                       gid_(),

                       mode_(),

                       inode_no_(),

                       link_count_(),

                       size_(),

                       blocks_() {}



Metadata::Metadata(mode_t mode) :

        atime_(),

fs/src/metadata.h

+1 −1
Original line number Diff line number Diff line
@@ -26,7 +26,7 @@ public: 


    Metadata(mode_t mode);



    //Getter and Setter

    //Getter and Setter TODO redo getter, setter

    time_t getAtime_() const;



    void setAtime_(time_t atime_);

fs/src/metadata_ops.cpp

+55 −0
Original line number Diff line number Diff line
@@ -4,4 +4,59 @@ 


#include "metadata_ops.h"



namespace fs = boost::filesystem;



// TODO error handling.

bool write_all_metadata(const Metadata& md, const std::string& path_str) {

    write_metadata_field(md.getAtime_(), md.getInode_no(), "/atime"s, path_str);

    write_metadata_field(md.getMtime_(), md.getInode_no(), "/mtime"s, path_str);

    write_metadata_field(md.getCtime_(), md.getInode_no(), "/ctime"s, path_str);

    write_metadata_field(md.getUid(), md.getInode_no(), "/uid"s, path_str);

    write_metadata_field(md.getGid(), md.getInode_no(), "/gid"s, path_str);

    write_metadata_field(md.getMode(), md.getInode_no(), "/mode"s, path_str);

    write_metadata_field(md.getInode_no(), md.getInode_no(), "/inode_no"s, path_str);

    write_metadata_field(md.getLink_count(), md.getInode_no(), "/link_count"s, path_str);

    write_metadata_field(md.getSize(), md.getInode_no(), "/size"s, path_str);

    write_metadata_field(md.getBlocks(), md.getInode_no(), "/blocks"s, path_str);



    return true;

}



bool read_all_metadata(Metadata& md, const uint64_t& inode, const std::string& path_str) {

    md.setAtime_(read_metadata_field(inode, "/atime"s, path_str));

    md.setMtime_(read_metadata_field(inode, "/mtime"s, path_str));

    md.setCtime_(read_metadata_field(inode, "/ctime"s, path_str));

    return true;

}



// TODO error handling.

template<typename T>

bool write_metadata_field(const T& field, const uint64_t& inode, const string& fname, const string& p) {

    auto i_path = p + "/" + to_string(inode);

    fs::create_directories(i_path);

    auto file = fs::path{i_path + fname};

    // for some reason auto ofs = fs::ofstream(file); does not work. That is why I use the old style.

    // std::basic_ofstream does not encounter this problem

    fs::ofstream ofs{file};



    ofs << field;

    return true;

}



//template<typename T>

time_t read_metadata_field(const uint64_t& inode, const string& fname, const string& p) {

    auto i_path = p + "/" + to_string(inode);

    if (!fs::exists(i_path)) return NULL;

    auto file = fs::path(i_path + fname);

    fs::ifstream ifs{file};

    //fast error checking

    //ifs.good()

    auto buf = ""s;

    getline(ifs, buf);

    time_t t = (time_t) stol(buf, nullptr);

    return t;

}



//std::unique_ptr<Metadata> read_metadata(const std::string& path) {

//    return nullptr;

//}