/******************************************************************** * 2014 - * open source under Apache License Version 2.0 ********************************************************************/ /** * 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 _HDFS_LIBHDFS3_CLIENT_FILESYSTEMINTER_H_ #define _HDFS_LIBHDFS3_CLIENT_FILESYSTEMINTER_H_ #include #include #include "BlockLocation.h" #include "DirectoryIterator.h" #include "EncryptionZoneIterator.h" #include "FileStatus.h" #include "FileSystemKey.h" #include "FileSystemStats.h" #include "EncryptionZoneInfo.h" #include "PeerCache.h" #include "Permission.h" #include "server/LocatedBlocks.h" #include "SessionConfig.h" #include "Unordered.h" #include "UserInfo.h" #include "XmlConfig.h" namespace Hdfs { class FileSystem; namespace Internal { class InputStreamInter; class OutputStreamInter; class FileSystemInter; struct FileSystemWrapper { public: FileSystemWrapper(shared_ptr fs) : filesystem(fs) { } shared_ptr filesystem; }; class FileSystemInter { public: /** * Destroy a FileSystemInter instance */ virtual ~FileSystemInter() { } /** * Format the path to a absolute canonicalized path. * @param path target path to be hendled. * @return return a absolute canonicalized path. */ virtual const std::string getStandardPath(const char * path) = 0; /** * To get the client unique ID. * @return return the client unique ID. */ virtual const char * getClientName() = 0; /** * Connect to hdfs */ virtual void connect() = 0; /** * disconnect from hdfs */ virtual void disconnect() = 0; /** * To get default number of replication. * @return the default number of replication. */ virtual int getDefaultReplication() const = 0; /** * To get the default block size. * @return the default block size. */ virtual int64_t getDefaultBlockSize() const = 0; /** * To get the home directory. * @return home directory. */ virtual std::string getHomeDirectory() const = 0; /** * To delete a file or directory. * @param path the path to be deleted. * @param recursive if path is a directory, delete the contents recursively. * @return return true if success. */ virtual bool deletePath(const char * path, bool recursive) = 0; /** * To create a directory which given permission. * @param path the directory path which is to be created. * @param permission directory permission. * @return return true if success. */ virtual bool mkdir(const char * path, const Permission & permission) = 0; /** * To create a directory which given permission. * If parent path does not exits, create it. * @param path the directory path which is to be created. * @param permission directory permission. * @return return true if success. */ virtual bool mkdirs(const char * path, const Permission & permission) = 0; /** * To get path information. * @param path the path which information is to be returned. * @return the path information. */ virtual FileStatus getFileStatus(const char * path) = 0; /** * Return an array containing hostnames, offset and size of * portions of the given file. * * This call is most helpful with DFS, where it returns * hostnames of machines that contain the given file. * * The FileSystem will simply return an elt containing 'localhost'. * * @param path path is used to identify an FS since an FS could have * another FS that it could be delegating the call to * @param start offset into the given file * @param len length for which to get locations for */ virtual std::vector getFileBlockLocations( const char * path, int64_t start, int64_t len) = 0; /** * list the contents of a directory. * @param path the directory path. * @return Return a iterator to visit all elements in this directory. */ virtual DirectoryIterator listDirectory(const char * path, bool needLocation) = 0; /** * list all the contents of a directory. * @param path The directory path. * @return Return a vector of file informations in the directory. */ virtual std::vector listAllDirectoryItems(const char * path, bool needLocation) = 0; /** * To set the owner and the group of the path. * username and groupname cannot be empty at the same time. * @param path the path which owner of group is to be changed. * @param username new user name. * @param groupname new group. */ virtual void setOwner(const char * path, const char * username, const char * groupname) = 0; /** * To set the access time or modification time of a path. * @param path the path which access time or modification time is to be changed. * @param mtime new modification time. * @param atime new access time. */ virtual void setTimes(const char * path, int64_t mtime, int64_t atime) = 0; /** * To set the permission of a path. * @param path the path which permission is to be changed. * @param permission new permission. */ virtual void setPermission(const char * path, const Permission & permission) = 0; /** * To set the number of replication. * @param path the path which number of replication is to be changed. * @param replication new number of replication. * @return return true if success. */ virtual bool setReplication(const char * path, short replication) = 0; /** * To rename a path. * @param src old path. * @param dst new path. * @return return true if success. */ virtual bool rename(const char * src, const char * dst) = 0; /** * To set working directory. * @param path new working directory. */ virtual void setWorkingDirectory(const char * path) = 0; /** * To get working directory. * @return working directory. */ virtual std::string getWorkingDirectory() const = 0; /** * To test if the path exist. * @param path the path which is to be tested. * @return return true if the path exist. */ virtual bool exist(const char * path) = 0; /** * To get the file system status. * @return the file system status. */ virtual FileSystemStats getFsStats() = 0; /** * Truncate the file in the indicated path to the indicated size. * @param src The path we will find the file to be truncated. * @param size the position we will truncate to. * @throw IOException */ virtual bool truncate(const char * src, int64_t size) /* throw AccessControlException, FileNotFoundException, UnresolvedLinkException, HdfsIOException */ = 0; /** * Get a valid Delegation Token. * * @param renewer the designated renewer for the token * @return Token * @throws IOException */ virtual std::string getDelegationToken(const char * renewer) = 0; /** * Get a valid Delegation Token using the default user as renewer. * * @return Token * @throws IOException */ virtual std::string getDelegationToken() = 0; /** * Renew an existing delegation token. * * @param token delegation token obtained earlier * @return the new expiration time * @throws IOException */ virtual int64_t renewDelegationToken(const std::string & token) = 0; /** * Cancel an existing delegation token. * * @param token delegation token * @throws IOException */ virtual void cancelDelegationToken(const std::string & token) = 0; /** * Get locations of the blocks of the specified file within the specified range. * DataNode locations for each block are sorted by * the proximity to the client. * * The client will then have to contact * one of the indicated DataNodes to obtain the actual data. * * @param src file name * @param offset range start offset * @param length range length * @param lbs output the returned blocks */ virtual void getBlockLocations(const std::string & src, int64_t offset, int64_t length, LocatedBlocks & lbs) = 0; /** * Create a new file entry in the namespace. * * @param src path of the file being created. * @param masked masked permission. * @param flag indicates whether the file should be * overwritten if it already exists or create if it does not exist or append. * @param createParent create missing parent directory if true * @param replication block replication factor. * @param blockSize maximum block size. */ virtual void create(const std::string & src, const Permission & masked, int flag, bool createParent, short replication, int64_t blockSize) = 0; /** * Append to the end of the file. * * @param src path of the file being created. * @return return the last partial block if any */ virtual std::pair, shared_ptr > append( const std::string& src) = 0; /** * The client can give up on a block by calling abandonBlock(). * The client can then either obtain a new block, or complete or abandon the file. * Any partial writes to the block will be discarded. * * @param b the block to be abandoned. * @param src the file which the block belongs to. */ virtual void abandonBlock(const ExtendedBlock & b, const std::string & srcr) = 0; /** * A client that wants to write an additional block to the * indicated filename (which must currently be open for writing) * should call addBlock(). * * addBlock() allocates a new block and datanodes the block data * should be replicated to. * * addBlock() also commits the previous block by reporting * to the name-node the actual generation stamp and the length * of the block that the client has transmitted to data-nodes. * * @param src the file being created * @param previous previous block * @param excludeNodes a list of nodes that should not be allocated for the current block. * @return return the new block. */ virtual shared_ptr addBlock(const std::string & src, const ExtendedBlock * previous, const std::vector & excludeNodes) = 0; /** * Get a datanode for an existing pipeline. * * @param src the file being written * @param blk the block being written * @param existings the existing nodes in the pipeline * @param excludes the excluded nodes * @param numAdditionalNodes number of additional datanodes * @return return a new block information which contains new datanode. */ virtual shared_ptr getAdditionalDatanode( const std::string & src, const ExtendedBlock & blk, const std::vector & existings, const std::vector & storageIDs, const std::vector & excludes, int numAdditionalNodes) = 0; /** * The client is done writing data to the given filename, and would * like to complete it. * * The function returns whether the file has been closed successfully. * If the function returns false, the caller should try again. * * close() also commits the last block of file by reporting * to the name-node the actual generation stamp and the length * of the block that the client has transmitted to data-nodes. * * A call to complete() will not return true until all the file's * blocks have been replicated the minimum number of times. Thus, * DataNode failures may cause a client to call complete() several * times before succeeding. * * @param src the file being written. * @param last last block to be committed. * @return return false if the client should retry. */ virtual bool complete(const std::string & src, const ExtendedBlock * last) = 0; /** * The client wants to report corrupted blocks (blocks with specified * locations on datanodes). * @param blocks Array of located blocks to report */ /*virtual void reportBadBlocks(const std::vector & blocks) = 0;*/ /** * Write all metadata for this file into persistent storage. * The file must be currently open for writing. * @param src The const std::string & representation of the path */ virtual void fsync(const std::string & src) = 0; /** * Get a new generation stamp together with an access token for * a block under construction * * This method is called only when a client needs to recover a failed * pipeline or set up a pipeline for appending to a block. * * @param block a block * @return return a located block with a new generation stamp and an access token */ virtual shared_ptr updateBlockForPipeline( const ExtendedBlock & block) = 0; /** * Update a pipeline for a block under construction * * @param clientName the name of the client * @param oldBlock the old block * @param newBlock the new block containing new generation stamp and length * @param newNodes datanodes in the pipeline * @throw HdfsIOException if any error occurs */ virtual void updatePipeline(const ExtendedBlock & oldBlock, const ExtendedBlock & newBlock, const std::vector & newNodes, const std::vector & storageIDs) = 0; /** * register the output stream in filespace when it is opened. */ virtual void registerOpenedOutputStream() = 0; /** * unregister the output stream from filespace when it is closed. */ virtual bool unregisterOpenedOutputStream() = 0; /** * Get the configuration used in filesystem. * @return return the configuration instance. */ virtual const SessionConfig & getConf() const = 0; /** * Get the user used in filesystem. * @return return the user information. */ virtual const UserInfo & getUserInfo() const = 0; /** * Get a partial listing of the indicated directory * * @param src the directory name * @param startAfter the name to start listing after encoded in java UTF8 * @param needLocation if the FileStatus should contain block locations * @param dl append the returned directories. * @return return true if there are more items. */ virtual bool getListing(const std::string & src, const std::string & startAfter, bool needLocation, std::vector & dl) = 0; /** * To renew the lease. * * @return return false if the filesystem no long needs to renew lease. */ virtual bool renewLease() = 0; /** * Get the peer cache. * * @return return the peer cache. */ virtual PeerCache& getPeerCache() = 0; /** * Create encryption zone for the directory with specific key name * @param path the directory path which is to be created. * @param keyname The key name of the encryption zone * @return return true if success. */ virtual bool createEncryptionZone(const char * path, const char * keyName) = 0; /** * To get encryption zone information. * @param path the path which information is to be returned. * @return the encryption zone information. */ virtual EncryptionZoneInfo getEZForPath(const char * path) = 0; /** * Get a partial listing of the indicated encryption zones * * @param id the index of encryption zones. * @param ezl append the returned encryption zones. * @return return true if there are more items. */ virtual bool listEncryptionZones(const int64_t id, std::vector & ezl) = 0; /** * list the contents of an encryption zone. * @return Return a iterator to visit all elements in this encryption zone. */ virtual EncryptionZoneIterator listEncryptionZone() = 0; /** * list all the contents of encryption zones. * @param id the index of encryption zones. * @return Return a vector of encryption zones information.. */ virtual std::vector listAllEncryptionZoneItems() = 0; }; } } #endif /* _HDFS_LIBHDFS3_CLIENT_FILESYSTEMINTER_H_ */