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

google coding style is old. using bjarne/herb style. Changed readmetadata to... 

google coding style is old. using bjarne/herb style. Changed readmetadata to pointer return type for errorhandling via nullptr.
parent 72d353ba

fs/src/main.cpp

+16 −16
Original line number Diff line number Diff line
@@ -10,23 +10,23 @@ using namespace std; 
//std::shared_ptr<Metadata> md;



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

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

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

    auto md = make_shared<Metadata>();

    md->setMode(S_IFDIR | 0755);

    md->setInode_no(1);

    ReadAllMetadata(*md, 1, fpath);

    md->mode(S_IFDIR | 0755);

    md->inode_no(1);

    read_all_metadata(*md, 1, fpath);

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

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

        attr->st_mode = md->getMode();

        attr->st_nlink = md->getLink_count();

        attr->st_uid = md->getUid();

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

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

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

        attr->st_mode = md->mode();

        attr->st_nlink = md->link_count();

        attr->st_uid = md->uid();

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

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

        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();

        attr->st_ctim.tv_sec = md->getCtime();

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

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

        attr->st_mtim.tv_sec = md->mtime();

        attr->st_ctim.tv_sec = md->ctime();

        return 0;

    }
@@ -59,10 +59,10 @@ void *adafs_init(struct fuse_conn_info *conn) { 
//        md = make_shared<Metadata>(S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO);

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

//    }

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

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

//



//    WriteAllMetadata(*md, s);

//    write_all_metadata(*md, s);



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

    ADAFS_DATA->logger->flush();

fs/src/main.h

+3 −3
Original line number Diff line number Diff line
@@ -29,11 +29,11 @@ struct adafs_data { 
#define ADAFS_DATA ((struct adafs_data*) fuse_get_context()->private_data)



namespace util {

    std::string AdafsFullpath(const std::string &path);

    std::string adafs_fullpath(const std::string &path);



    int ResetInodeNo(void);

    int reset_inode_no();



    ino_t GenerateInodeNo(void);

    ino_t generate_inode_no();

}



#endif //MAIN_H

fs/src/metadata.cpp

+32 −36
Original line number Diff line number Diff line
@@ -4,88 +4,84 @@ 


#include "metadata.h"



time_t Metadata::getAtime() const {

time_t Metadata::atime() const {

    return atime_;

}



void Metadata::setAtime(time_t atime) {

    Metadata::atime_ = atime;

void Metadata::atime(time_t atime_) {

    Metadata::atime_ = atime_;

}



time_t Metadata::getMtime() const {

time_t Metadata::mtime() const {

    return mtime_;

}



void Metadata::setMtime(time_t mtime) {

    Metadata::mtime_ = mtime;

void Metadata::mtime(time_t mtime_) {

    Metadata::mtime_ = mtime_;

}



time_t Metadata::getCtime() const {

time_t Metadata::ctime() const {

    return ctime_;

}



void Metadata::setCtime(time_t ctime_) {

void Metadata::ctime(time_t ctime_) {

    Metadata::ctime_ = ctime_;

}



void Metadata::setCtime(uint32_t ctime) {

    Metadata::ctime_ = ctime;

}



uint32_t Metadata::getUid() const {

uint32_t Metadata::uid() const {

    return uid_;

}



void Metadata::setUid(uint32_t uid) {

    Metadata::uid_ = uid;

void Metadata::uid(uint32_t uid_) {

    Metadata::uid_ = uid_;

}



uint32_t Metadata::getGid() const {

uint32_t Metadata::gid() const {

    return gid_;

}



void Metadata::setGid(uint32_t gid) {

    Metadata::gid_ = gid;

void Metadata::gid(uint32_t gid_) {

    Metadata::gid_ = gid_;

}



uint32_t Metadata::getMode() const {

uint32_t Metadata::mode() const {

    return mode_;

}



void Metadata::setMode(uint32_t mode) {

    Metadata::mode_ = mode;

void Metadata::mode(uint32_t mode_) {

    Metadata::mode_ = mode_;

}



uint64_t Metadata::getInode_no() const {

uint64_t Metadata::inode_no() const {

    return inode_no_;

}



void Metadata::setInode_no(uint64_t inode_no) {

    Metadata::inode_no_ = inode_no;

void Metadata::inode_no(uint64_t inode_no_) {

    Metadata::inode_no_ = inode_no_;

}



uint32_t Metadata::getLink_count() const {

uint32_t Metadata::link_count() const {

    return link_count_;

}



void Metadata::setLink_count(uint32_t link_count) {

    Metadata::link_count_ = link_count;

void Metadata::link_count(uint32_t link_count_) {

    Metadata::link_count_ = link_count_;

}



uint32_t Metadata::getSize() const {

uint32_t Metadata::size() const {

    return size_;

}



void Metadata::setSize(uint32_t size) {

    Metadata::size_ = size;

void Metadata::size(uint32_t size_) {

    Metadata::size_ = size_;

}



uint32_t Metadata::getBlocks() const {

uint32_t Metadata::blocks() const {

    return blocks_;

}



void Metadata::setBlocks(uint32_t blocks) {

    Metadata::blocks_ = blocks;

void Metadata::blocks(uint32_t blocks_) {

    Metadata::blocks_ = blocks_;

}



//--------------------------------------------
@@ -113,11 +109,11 @@ Metadata::Metadata(mode_t mode) : 
        link_count_(0),

        size_(0),

        blocks_(0) {

    InitAcmTime();

    inode_no_ = util::GenerateInodeNo();

    init_ACM_time();

    inode_no_ = util::generate_inode_no();

}



void Metadata::InitAcmTime(void) {

void Metadata::init_ACM_time() {

    std::time_t time;

    std::time(&time);

    atime_ = time;

fs/src/metadata.h

+21 −23
Original line number Diff line number Diff line
@@ -19,7 +19,7 @@ private: 
    uint32_t size_;              // size_ in bytes, might be computed instead of stored

    uint32_t blocks_;            // allocated file system blocks_



    void InitAcmTime(void);

    void init_ACM_time();



public:

    Metadata();
@@ -27,47 +27,45 @@ public: 
    Metadata(mode_t mode);



    //Getter and Setter

    time_t getAtime() const;

    time_t atime() const;



    void setAtime(time_t atime);

    void atime(time_t atime_);



    time_t getMtime() const;

    time_t mtime() const;



    void setMtime(time_t mtime);

    void mtime(time_t mtime_);



    time_t getCtime() const;

    time_t ctime() const;



    void setCtime(time_t ctime_);

    void ctime(time_t ctime_);



    void setCtime(uint32_t ctime);

    uint32_t uid() const;



    uint32_t getUid() const;

    void uid(uint32_t uid_);



    void setUid(uint32_t uid);

    uint32_t gid() const;



    uint32_t getGid() const;

    void gid(uint32_t gid_);



    void setGid(uint32_t gid);

    uint32_t mode() const;



    uint32_t getMode() const;

    void mode(uint32_t mode_);



    void setMode(uint32_t mode);

    uint64_t inode_no() const;



    uint64_t getInode_no() const;

    void inode_no(uint64_t inode_no_);



    void setInode_no(uint64_t inode_no);

    uint32_t link_count() const;



    uint32_t getLink_count() const;

    void link_count(uint32_t link_count_);



    void setLink_count(uint32_t link_count);

    uint32_t size() const;



    uint32_t getSize() const;

    void size(uint32_t size_);



    void setSize(uint32_t size);

    uint32_t blocks() const;



    uint32_t getBlocks() const;



    void setBlocks(uint32_t blocks);

    void blocks(uint32_t blocks_);



};

fs/src/metadata_ops.cpp

+29 −21
Original line number Diff line number Diff line
@@ -9,32 +9,40 @@ 


namespace fs = boost::filesystem;



// TODO error handling.

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

    WriteMetadataField(md.getAtime(), md.getInode_no(), "/atime"s, path_str);

    WriteMetadataField(md.getMtime(), md.getInode_no(), "/mtime"s, path_str);

    WriteMetadataField(md.getCtime(), md.getInode_no(), "/ctime"s, path_str);

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

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

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

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

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

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

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

// TODO error handling. Each read_metadata_field should check for boolean, i.e., if I/O failed.

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

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

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

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

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

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

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

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

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

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

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



    return true;

}



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

    md.setAtime(ReadMetadataField<time_t>(inode, "/atime"s, path_str));

    md.setMtime(ReadMetadataField<time_t>(inode, "/mtime"s, path_str));

    md.setCtime(ReadMetadataField<time_t>(inode, "/ctime"s, path_str));

// TODO error handling. Each read_metadata_field should check for nullptr, i.e., if I/O failed.

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

    md.atime(*read_metadata_field<time_t>(inode, "/atime"s, path_str));

    md.mtime(*read_metadata_field<time_t>(inode, "/mtime"s, path_str));

    md.ctime(*read_metadata_field<time_t>(inode, "/ctime"s, path_str));

    md.uid(*read_metadata_field<uint32_t>(inode, "/uid"s, path_str));

    md.gid(*read_metadata_field<uint32_t>(inode, "/gid"s, path_str));

    md.mode(*read_metadata_field<uint32_t>(inode, "/mode"s, path_str));

    md.inode_no(*read_metadata_field<uint64_t>(inode, "/inode_no"s, path_str));

    md.link_count(*read_metadata_field<uint32_t>(inode, "/link_count"s, path_str));

    md.size(*read_metadata_field<uint32_t>(inode, "/size"s, path_str));

    md.blocks(*read_metadata_field<uint32_t>(inode, "/blocks"s, path_str));

    return true;

}



// TODO error handling.

template<typename T>

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

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};
@@ -49,16 +57,16 @@ bool WriteMetadataField(const T &field, const uint64_t &inode, const string &fna 
}



template<typename T>

T ReadMetadataField(const uint64_t &inode, const string &fname, const string &p) {

unique_ptr<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 nullptr;

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

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

    fs::ifstream ifs{file};

    //fast error checking

    //ifs.good()

    boost::archive::binary_iarchive ba(ifs);

    T field;

    ba >> field;

    auto field = make_unique<T>();

    ba >> *field;

    return field;

}