Filesystem.h

Go to the documentation of this file.

/* -*- c++ -*-
 * Copyright (C) 2007-2015 Hypertable, Inc.
 *
 * This file is part of Hypertable.
 *
 * Hypertable 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; version 3 of the
 * License, or any later version.
 *
 * Hypertable 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 this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */

#ifndef Common_Filesystem_h
#define Common_Filesystem_h

#include <AsyncComm/DispatchHandler.h>

#include <Common/Serializable.h>
#include <Common/String.h>
#include <Common/StaticBuffer.h>
#include <Common/Status.h>
#include <Common/Timer.h>

#include <memory>
#include <string>
#include <vector>

using namespace std;

#define HT_DIRECT_IO_ALIGNMENT      512

#define HT_IO_ALIGNED(size)                     \
    (((size) % HT_DIRECT_IO_ALIGNMENT) == 0)

#define HT_IO_ALIGNMENT_PADDING(size)           \
    (HT_DIRECT_IO_ALIGNMENT - ((size) % HT_DIRECT_IO_ALIGNMENT))

namespace Hypertable {


  class Filesystem {
  public:

    enum class Flags : uint8_t {
      NONE=0,
      FLUSH=1,
      SYNC=2
    };

    enum OpenFlags {
      OPEN_FLAG_DIRECTIO = 0x00000001,
      OPEN_FLAG_OVERWRITE = 0x00000002,
      OPEN_FLAG_VERIFY_CHECKSUM = 0x00000004
    };

    class Dirent : public Serializable {

    public:
      String name;
      uint64_t length {};
      time_t last_modification_time {};
      bool is_dir {};

    private:

      uint8_t encoding_version() const override;

      size_t encoded_length_internal() const override;

      void encode_internal(uint8_t **bufp) const override;

      void decode_internal(uint8_t version, const uint8_t **bufp,
                           size_t *remainp) override;
      
    };

    virtual ~Filesystem() { }

    virtual void open(const String &name, uint32_t flags,
            DispatchHandler *handler) = 0;

    virtual int open(const String &name, uint32_t flags) = 0;

    virtual int open_buffered(const String &name, uint32_t flags,
            uint32_t buf_size, uint32_t outstanding, uint64_t start_offset = 0,
            uint64_t end_offset = 0) = 0;

    virtual void decode_response_open(EventPtr &event, int32_t *fd) = 0;

    virtual void create(const String &name, uint32_t flags, int32_t bufsz,
            int32_t replication, int64_t blksz, DispatchHandler *handler) = 0;

    virtual int create(const String &name, uint32_t flags, int32_t bufsz,
            int32_t replication, int64_t blksz) = 0;

    virtual void decode_response_create(EventPtr &event, int32_t *fd) = 0;

    virtual void close(int fd, DispatchHandler *handler) = 0;

    virtual void close(int fd) = 0;

    virtual void read(int fd, size_t len, DispatchHandler *handler) = 0;

    virtual size_t read(int fd, void *dst, size_t len) = 0;

    virtual void decode_response_read(EventPtr &event, const void **buffer,
                                      uint64_t *offset, uint32_t *length) = 0;

    virtual void append(int fd, StaticBuffer &buffer, Flags flags,
            DispatchHandler *handler) = 0;

    virtual size_t append(int fd, StaticBuffer &buffer, Flags flags = Flags::NONE) = 0;

    virtual void decode_response_append(EventPtr &event, uint64_t *offset,
                                        uint32_t *length) = 0;

    virtual void seek(int fd, uint64_t offset, DispatchHandler *handler) = 0;

    virtual void seek(int fd, uint64_t offset) = 0;

    virtual void remove(const String &name, DispatchHandler *handler) = 0;

    virtual void remove(const String &name, bool force = true) = 0;

    virtual void length(const String &name, bool accurate,
            DispatchHandler *handler) = 0;

    virtual int64_t length(const String &name, bool accurate = true) = 0;

    virtual int64_t decode_response_length(EventPtr &event) = 0;

    virtual void pread(int fd, size_t amount, uint64_t offset,
                       bool verify_checksum, DispatchHandler *handler) = 0;

    virtual size_t pread(int fd, void *dst, size_t len, uint64_t offset,
            bool verify_checksum = true) = 0;

    virtual void decode_response_pread(EventPtr &event, const void **buffer,
                                       uint64_t *offset, uint32_t *length) = 0;

    virtual void mkdirs(const String &name, DispatchHandler *handler) = 0;

    virtual void mkdirs(const String &name) = 0;

    virtual void rmdir(const String &name, DispatchHandler *handler) = 0;

    virtual void rmdir(const String &name, bool force = true) = 0;

    virtual void readdir(const String &name, DispatchHandler *handler) = 0;

    virtual void readdir(const String &name, std::vector<Dirent> &listing) = 0;

    virtual void decode_response_readdir(EventPtr &event,
                                         std::vector<Dirent> &listing) = 0;

    virtual void flush(int fd, DispatchHandler *handler) = 0;

    virtual void flush(int fd) = 0;

    virtual void sync(int fd) = 0;

    virtual void exists(const String &name, DispatchHandler *handler) = 0;

    virtual bool exists(const String &name) = 0;

    virtual bool decode_response_exists(EventPtr &event) = 0;

    virtual void rename(const String &src, const String &dst,
            DispatchHandler *handler) = 0;

    virtual void rename(const String &src, const String &dst) = 0;

    virtual void status(Status &status, Timer *timer=0) = 0;

    virtual void decode_response_status(EventPtr &event, Status &status) = 0;

    static int decode_response(EventPtr &event);

    virtual void debug(int32_t command,
            StaticBuffer &serialized_parameters) = 0;

    virtual void debug(int32_t command, StaticBuffer &serialized_parameters,
            DispatchHandler *handler) = 0;

    static String dirname(String name, char separator = '/');

    static String basename(String name, char separator = '/');
  };

  typedef std::shared_ptr<Filesystem> FilesystemPtr;

  inline bool operator< (const Filesystem::Dirent& lhs,
                         const Filesystem::Dirent& rhs) {
    return lhs.name.compare(rhs.name) < 0;
  }

  extern Filesystem::Flags convert(std::string str);


} // namespace Hypertable

#endif // Common_Filesystem_h