EIC code displayed by LXR master/​include/​arrow/​io/​hdfs.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-08-28 08:26:59

 // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
 // regarding copyright ownership.  The ASF licenses this file
 // to you under the Apache License, Version 2.0 (the
 // "License"); you may not use this file except in compliance
 // with the License.  You may obtain a copy of the License at
 //
 //   http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing,
 // software distributed under the License is distributed on an
 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
 
 #pragma once
 
 #include <cstdint>
 #include <memory>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
 #include "arrow/io/interfaces.h"
 #include "arrow/util/macros.h"
 #include "arrow/util/visibility.h"
 
 namespace arrow {
 
 class Buffer;
 class MemoryPool;
 class Status;
 
 namespace io {
 
 class HdfsReadableFile;
 class HdfsOutputStream;
 
 /// DEPRECATED.  Use the FileSystem API in arrow::fs instead.
 struct ObjectType {
   enum type { FILE, DIRECTORY };
 };
 
 /// DEPRECATED.  Use the FileSystem API in arrow::fs instead.
 struct ARROW_EXPORT FileStatistics {
   /// Size of file, -1 if finding length is unsupported
   int64_t size;
   ObjectType::type kind;
 };
 
 class ARROW_EXPORT FileSystem {
  public:
   virtual ~FileSystem() = default;
 
   virtual Status MakeDirectory(const std::string& path) = 0;
 
   virtual Status DeleteDirectory(const std::string& path) = 0;
 
   virtual Status GetChildren(const std::string& path,
                              std::vector<std::string>* listing) = 0;
 
   virtual Status Rename(const std::string& src, const std::string& dst) = 0;
 
   virtual Status Stat(const std::string& path, FileStatistics* stat) = 0;
 };
 
 struct HdfsPathInfo {
   ObjectType::type kind;
 
   std::string name;
   std::string owner;
   std::string group;
 
   // Access times in UNIX timestamps (seconds)
   int64_t size;
   int64_t block_size;
 
   int32_t last_modified_time;
   int32_t last_access_time;
 
   int16_t replication;
   int16_t permissions;
 };
 
 struct HdfsConnectionConfig {
   std::string host;
   int port;
   std::string user;
   std::string kerb_ticket;
   std::unordered_map<std::string, std::string> extra_conf;
 };
 
 class ARROW_EXPORT HadoopFileSystem : public FileSystem {
  public:
   ~HadoopFileSystem() override;
 
   // Connect to an HDFS cluster given a configuration
   //
   // @param config (in): configuration for connecting
   // @param fs (out): the created client
   // @returns Status
   static Status Connect(const HdfsConnectionConfig* config,
                         std::shared_ptr<HadoopFileSystem>* fs);
 
   // Create directory and all parents
   //
   // @param path (in): absolute HDFS path
   // @returns Status
   Status MakeDirectory(const std::string& path) override;
 
   // Delete file or directory
   // @param path absolute path to data
   // @param recursive if path is a directory, delete contents as well
   // @returns error status on failure
   Status Delete(const std::string& path, bool recursive = false);
 
   Status DeleteDirectory(const std::string& path) override;
 
   // Disconnect from cluster
   //
   // @returns Status
   Status Disconnect();
 
   // @param path (in): absolute HDFS path
   // @returns bool, true if the path exists, false if not (or on error)
   bool Exists(const std::string& path);
 
   // @param path (in): absolute HDFS path
   // @param info (out)
   // @returns Status
   Status GetPathInfo(const std::string& path, HdfsPathInfo* info);
 
   // @param nbytes (out): total capacity of the filesystem
   // @returns Status
   Status GetCapacity(int64_t* nbytes);
 
   // @param nbytes (out): total bytes used of the filesystem
   // @returns Status
   Status GetUsed(int64_t* nbytes);
 
   Status GetChildren(const std::string& path, std::vector<std::string>* listing) override;
 
   /// List directory contents
   ///
   /// If path is a relative path, returned values will be absolute paths or URIs
   /// starting from the current working directory.
   Status ListDirectory(const std::string& path, std::vector<HdfsPathInfo>* listing);
 
   /// Return the filesystem's current working directory.
   ///
   /// The working directory is the base path for all relative paths given to
   /// other APIs.
   /// NOTE: this actually returns a URI.
   Status GetWorkingDirectory(std::string* out);
 
   /// Change
   ///
   /// @param path file path to change
   /// @param owner pass null for no change
   /// @param group pass null for no change
   Status Chown(const std::string& path, const char* owner, const char* group);
 
   /// Change path permissions
   ///
   /// \param path Absolute path in file system
   /// \param mode Mode bitset
   /// \return Status
   Status Chmod(const std::string& path, int mode);
 
   // Move file or directory from source path to destination path within the
   // current filesystem
   Status Rename(const std::string& src, const std::string& dst) override;
 
   Status Copy(const std::string& src, const std::string& dst);
 
   Status Move(const std::string& src, const std::string& dst);
 
   Status Stat(const std::string& path, FileStatistics* stat) override;
 
   // TODO(wesm): GetWorkingDirectory, SetWorkingDirectory
 
   // Open an HDFS file in READ mode. Returns error
   // status if the file is not found.
   //
   // @param path complete file path
   Status OpenReadable(const std::string& path, int32_t buffer_size,
                       std::shared_ptr<HdfsReadableFile>* file);
 
   Status OpenReadable(const std::string& path, int32_t buffer_size,
                       const io::IOContext& io_context,
                       std::shared_ptr<HdfsReadableFile>* file);
 
   Status OpenReadable(const std::string& path, std::shared_ptr<HdfsReadableFile>* file);
 
   Status OpenReadable(const std::string& path, const io::IOContext& io_context,
                       std::shared_ptr<HdfsReadableFile>* file);
 
   // FileMode::WRITE options
   // @param path complete file path
   // @param buffer_size 0 by default
   // @param replication 0 by default
   // @param default_block_size 0 by default
   Status OpenWritable(const std::string& path, bool append, int32_t buffer_size,
                       int16_t replication, int64_t default_block_size,
                       std::shared_ptr<HdfsOutputStream>* file);
 
   Status OpenWritable(const std::string& path, bool append,
                       std::shared_ptr<HdfsOutputStream>* file);
 
  private:
   friend class HdfsReadableFile;
   friend class HdfsOutputStream;
 
   class ARROW_NO_EXPORT HadoopFileSystemImpl;
   std::unique_ptr<HadoopFileSystemImpl> impl_;
 
   HadoopFileSystem();
   ARROW_DISALLOW_COPY_AND_ASSIGN(HadoopFileSystem);
 };
 
 class ARROW_EXPORT HdfsReadableFile : public RandomAccessFile {
  public:
   ~HdfsReadableFile() override;
 
   Status Close() override;
 
   bool closed() const override;
 
   // NOTE: If you wish to read a particular range of a file in a multithreaded
   // context, you may prefer to use ReadAt to avoid locking issues
   Result<int64_t> Read(int64_t nbytes, void* out) override;
   Result<std::shared_ptr<Buffer>> Read(int64_t nbytes) override;
   Result<int64_t> ReadAt(int64_t position, int64_t nbytes, void* out) override;
   Result<std::shared_ptr<Buffer>> ReadAt(int64_t position, int64_t nbytes) override;
 
   Status Seek(int64_t position) override;
   Result<int64_t> Tell() const override;
   Result<int64_t> GetSize() override;
 
  private:
   explicit HdfsReadableFile(const io::IOContext&);
 
   class ARROW_NO_EXPORT HdfsReadableFileImpl;
   std::unique_ptr<HdfsReadableFileImpl> impl_;
 
   friend class HadoopFileSystem::HadoopFileSystemImpl;
 
   ARROW_DISALLOW_COPY_AND_ASSIGN(HdfsReadableFile);
 };
 
 // Naming this file OutputStream because it does not support seeking (like the
 // WritableFile interface)
 class ARROW_EXPORT HdfsOutputStream : public OutputStream {
  public:
   ~HdfsOutputStream() override;
 
   Status Close() override;
 
   bool closed() const override;
 
   using OutputStream::Write;
   Status Write(const void* buffer, int64_t nbytes) override;
 
   Status Flush() override;
 
   Result<int64_t> Tell() const override;
 
  private:
   class ARROW_NO_EXPORT HdfsOutputStreamImpl;
   std::unique_ptr<HdfsOutputStreamImpl> impl_;
 
   friend class HadoopFileSystem::HadoopFileSystemImpl;
 
   HdfsOutputStream();
 
   ARROW_DISALLOW_COPY_AND_ASSIGN(HdfsOutputStream);
 };
 
 ARROW_EXPORT Status HaveLibHdfs();
 
 }  // namespace io
 }  // namespace arrow

This page was automatically generated by the 2.3.7 LXR engine. The LXR team