| /** |
| * 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. |
| */ |
| #ifndef LIBHDFSPP_LIB_FS_NAMENODEOPERATIONS_H_ |
| #define LIBHDFSPP_LIB_FS_NAMENODEOPERATIONS_H_ |
| |
| #include "rpc/rpc_engine.h" |
| #include "hdfspp/statinfo.h" |
| #include "hdfspp/fsinfo.h" |
| #include "hdfspp/content_summary.h" |
| #include "common/namenode_info.h" |
| #include "ClientNamenodeProtocol.pb.h" |
| #include "ClientNamenodeProtocol.hrpc.inl" |
| |
| #include <memory> |
| #include <string> |
| |
| namespace hdfs { |
| |
| /** |
| * NameNodeConnection: abstracts the details of communicating with a NameNode |
| * and the implementation of the communications protocol. |
| * |
| * Will eventually handle retry and failover. |
| * |
| * Threading model: thread-safe; all operations can be called concurrently |
| * Lifetime: owned by a FileSystemImpl |
| */ |
| |
| class NameNodeOperations { |
| public: |
| MEMCHECKED_CLASS(NameNodeOperations) |
| NameNodeOperations(std::shared_ptr<IoService> io_service, const Options &options, |
| const std::shared_ptr<std::string> &client_name, const std::string &user_name, |
| const char *protocol_name, int protocol_version) : |
| io_service_(io_service), |
| engine_(std::make_shared<RpcEngine>(io_service, options, client_name, user_name, protocol_name, protocol_version)), |
| namenode_(engine_), options_(options) {} |
| |
| |
| void Connect(const std::string &cluster_name, |
| const std::vector<ResolvedNamenodeInfo> &servers, |
| std::function<void(const Status &)> &&handler); |
| |
| bool CancelPendingConnect(); |
| |
| void GetBlockLocations(const std::string & path, uint64_t offset, uint64_t length, |
| std::function<void(const Status &, std::shared_ptr<const struct FileInfo>)> handler); |
| |
| void GetPreferredBlockSize(const std::string & path, |
| std::function<void(const Status &, const uint64_t)> handler); |
| |
| void SetReplication(const std::string & path, int16_t replication, |
| std::function<void(const Status &)> handler); |
| |
| void SetTimes(const std::string & path, uint64_t mtime, uint64_t atime, |
| std::function<void(const Status &)> handler); |
| |
| void GetFileInfo(const std::string & path, |
| std::function<void(const Status &, const StatInfo &)> handler); |
| |
| void GetContentSummary(const std::string & path, |
| std::function<void(const Status &, const ContentSummary &)> handler); |
| |
| void GetFsStats(std::function<void(const Status &, const FsInfo &)> handler); |
| |
| // start_after="" for initial call |
| void GetListing(const std::string & path, |
| std::function<void(const Status &, const std::vector<StatInfo> &, bool)> handler, |
| const std::string & start_after = ""); |
| |
| void Mkdirs(const std::string & path, uint16_t permissions, bool createparent, |
| std::function<void(const Status &)> handler); |
| |
| void Delete(const std::string & path, bool recursive, |
| std::function<void(const Status &)> handler); |
| |
| void Rename(const std::string & oldPath, const std::string & newPath, |
| std::function<void(const Status &)> handler); |
| |
| void SetPermission(const std::string & path, uint16_t permissions, |
| std::function<void(const Status &)> handler); |
| |
| void SetOwner(const std::string & path, const std::string & username, |
| const std::string & groupname, std::function<void(const Status &)> handler); |
| |
| void CreateSnapshot(const std::string & path, const std::string & name, |
| std::function<void(const Status &)> handler); |
| |
| void DeleteSnapshot(const std::string & path, const std::string & name, |
| std::function<void(const Status &)> handler); |
| |
| void RenameSnapshot(const std::string & path, const std::string & old_name, const std::string & new_name, |
| std::function<void(const Status &)> handler); |
| |
| void AllowSnapshot(const std::string & path, |
| std::function<void(const Status &)> handler); |
| |
| void DisallowSnapshot(const std::string & path, |
| std::function<void(const Status &)> handler); |
| |
| void SetFsEventCallback(fs_event_callback callback); |
| |
| private: |
| static void HdfsFileStatusProtoToStatInfo(hdfs::StatInfo & si, const ::hadoop::hdfs::HdfsFileStatusProto & fs); |
| static void ContentSummaryProtoToContentSummary(hdfs::ContentSummary & content_summary, const ::hadoop::hdfs::ContentSummaryProto & csp); |
| static void DirectoryListingProtoToStatInfo(std::shared_ptr<std::vector<StatInfo>> stat_infos, const ::hadoop::hdfs::DirectoryListingProto & dl); |
| static void GetFsStatsResponseProtoToFsInfo(hdfs::FsInfo & fs_info, const std::shared_ptr<::hadoop::hdfs::GetFsStatsResponseProto> & fs); |
| |
| std::shared_ptr<IoService> io_service_; |
| |
| // This is the only permanent owner of the RpcEngine, however the RPC layer |
| // needs to reference count it prevent races during FileSystem destruction. |
| // In order to do this they hold weak_ptrs and promote them to shared_ptr |
| // when calling non-blocking RpcEngine methods e.g. get_client_id(). |
| std::shared_ptr<RpcEngine> engine_; |
| |
| // Automatically generated methods for RPC calls. See protoc_gen_hrpc.cc |
| ClientNamenodeProtocol namenode_; |
| const Options options_; |
| }; |
| } |
| |
| #endif |