/******************************************************************** * 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_SERVER_NAMENODE_H_ #define _HDFS_LIBHDFS3_SERVER_NAMENODE_H_ #include "client/FileStatus.h" #include "client/EncryptionZoneInfo.h" #include "client/Permission.h" #include "DatanodeInfo.h" #include "Exception.h" #include "ExtendedBlock.h" #include "LocatedBlock.h" #include "LocatedBlocks.h" #include "rpc/RpcAuth.h" #include "rpc/RpcCall.h" #include "rpc/RpcClient.h" #include "rpc/RpcConfig.h" #include "rpc/RpcProtocolInfo.h" #include "rpc/RpcServerInfo.h" #include "SessionConfig.h" #include namespace Hdfs { namespace Internal { class Namenode { public: /** * Destroy the namenode. */ virtual ~Namenode() { } /** * 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. *

* Return {//link LocatedBlocks} which contains * file length, blocks and their locations. * DataNode locations for each block are sorted by * the distance to the client's address. *

* 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 file length and array of blocks with their locations * @param lbs output the returned blocks * * @throw AccessControlException If access is denied * @throw FileNotFoundException If file src does not exist * @throw UnresolvedLinkException If src contains a symlink * @throw HdfsIOException If an I/O error occurred */ //Idempotent virtual void getBlockLocations(const std::string & src, int64_t offset, int64_t length, LocatedBlocks & lbs) /* throw (AccessControlException, FileNotFoundException, UnresolvedLinkException, HdfsIOException) */ = 0; /** * Create a new file entry in the namespace. *

* This will create an empty file specified by the source path. * The path should reflect a full path originated at the root. * The name-node does not have a notion of "current" directory for a client. *

* Once created, the file is visible and available for read to other clients. * Although, other clients cannot {//link #delete(const std::string &, bool)}, re-create or * {//link #rename(const std::string &, const std::string &)} it until the file is completed * or explicitly as a result of lease expiration. *

* Blocks have a maximum size. Clients that intend to create * multi-block files must also use * {//link #addBlock(const std::string &, const std::string &, ExtendedBlock, DatanodeInfo[])} * * @param src path of the file being created. * @param masked masked permission. * @param clientName name of the current client. * @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. * * @throw AccessControlException If access is denied * @throw AlreadyBeingCreatedException if the path does not exist. * @throw DSQuotaExceededException If file creation violates disk space * quota restriction * @throw FileAlreadyExistsException If file src already exists * @throw FileNotFoundException If parent of src does not exist * and createParent is false * @throw ParentNotDirectoryException If parent of src is not a * directory. * @throw NSQuotaExceededException If file creation violates name space * quota restriction * @throw SafeModeException create not allowed in safemode * @throw UnresolvedLinkException If src contains a symlink * @throw HdfsIOException If an I/O error occurred * * RuntimeExceptions: * @throw InvalidPathException Path src is invalid */ virtual void create(const std::string & src, const Permission & masked, const std::string & clientName, int flag, bool createParent, short replication, int64_t blockSize) /* throw (AccessControlException, AlreadyBeingCreatedException, DSQuotaExceededException, FileAlreadyExistsException, FileNotFoundException, NSQuotaExceededException, ParentNotDirectoryException, SafeModeException, UnresolvedLinkException, HdfsIOException) */ = 0; /** * Append to the end of the file. * @param src path of the file being created. * @param clientName name of the current client. * @param information about the last partial block if any. * @param lb output the returned block.s * * @throw AccessControlException if permission to append file is * denied by the system. As usually on the client side the exception will * be wrapped into {//link org.apache.hadoop.ipc.RemoteException}. * Allows appending to an existing file if the server is * configured with the parameter dfs.support.append set to true, otherwise * throw an HdfsIOException. * * @throw AccessControlException If permission to append to file is denied * @throw FileNotFoundException If file src is not found * @throw DSQuotaExceededException If append violates disk space quota * restriction * @throw SafeModeException append not allowed in safemode * @throw UnresolvedLinkException If src contains a symlink * @throw HdfsIOException If an I/O error occurred. * * RuntimeExceptions: * @throw UnsupportedOperationException if append is not supported */ virtual std::pair, shared_ptr> append( const std::string& src, const std::string& clientName) /* throw (AccessControlException, DSQuotaExceededException, FileNotFoundException, SafeModeException, UnresolvedLinkException, HdfsIOException) */ = 0; /** * Set replication for an existing file. *

* The NameNode sets replication to the new value and returns. * The actual block replication is not expected to be performed during * this method call. The blocks will be populated or removed in the * background as the result of the routine block maintenance procedures. * * @param src file name * @param replication new replication * * @param true if successful) = 0; * false if file does not exist or is a directory * * @throw AccessControlException If access is denied * @throw DSQuotaExceededException If replication violates disk space * quota restriction * @throw FileNotFoundException If file src is not found * @throw SafeModeException not allowed in safemode * @throw UnresolvedLinkException if src contains a symlink * @throw HdfsIOException If an I/O error occurred */ //Idempotent virtual bool setReplication(const std::string & src, short replication) /* throw (AccessControlException, DSQuotaExceededException, FileNotFoundException, SafeModeException, UnresolvedLinkException, HdfsIOException) */ = 0; /** * Set permissions for an existing file/directory. * * @throw AccessControlException If access is denied * @throw FileNotFoundException If file src is not found * @throw SafeModeException not allowed in safemode * @throw UnresolvedLinkException If src contains a symlink * @throw HdfsIOException If an I/O error occurred */ //Idempotent virtual void setPermission(const std::string & src, const Permission & permission) /* throw (AccessControlException, FileNotFoundException, SafeModeException, UnresolvedLinkException, HdfsIOException) */ = 0; /** * Set Owner of a path (i.e. a file or a directory). * The parameters username and groupname cannot both be null. * @param src * @param username If it is null, the original username remains unchanged. * @param groupname If it is null, the original groupname remains unchanged. * * @throw AccessControlException If access is denied * @throw FileNotFoundException If file src is not found * @throw SafeModeException not allowed in safemode * @throw UnresolvedLinkException If src contains a symlink * @throw HdfsIOException If an I/O error occurred */ //Idempotent virtual void setOwner(const std::string & src, const std::string & username, const std::string & groupname) /* throw (AccessControlException, FileNotFoundException, SafeModeException, UnresolvedLinkException, HdfsIOException) */ = 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. * * @throw AccessControlException If access is denied * @throw FileNotFoundException file src is not found * @throw UnresolvedLinkException If src contains a symlink * @throw HdfsIOException If an I/O error occurred */ virtual void abandonBlock(const ExtendedBlock & b, const std::string & src, const std::string & holder) /* throw (AccessControlException, FileNotFoundException, UnresolvedLinkException, HdfsIOException) */ = 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 clientName the name of the client that adds the block * @param previous previous block * @param excludeNodes a list of nodes that should not be * allocated for the current block * * @param LocatedBlock allocated block information. * @param lb output the returned block. * * @throw AccessControlException If access is denied * @throw FileNotFoundException If file src is not found * @throw NotReplicatedYetException previous blocks of the file are not * replicated yet. Blocks cannot be added until replication * completes. * @throw SafeModeException create not allowed in safemode * @throw UnresolvedLinkException If src contains a symlink * @throw HdfsIOException If an I/O error occurred */ virtual shared_ptr addBlock(const std::string & src, const std::string & clientName, const ExtendedBlock * previous, const std::vector & excludeNodes) /* throw (AccessControlException, FileNotFoundException, NotReplicatedYetException, SafeModeException, UnresolvedLinkException, HdfsIOException) */ = 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 * @param clientName the name of the client * * @param the located block. * @param output the returned block. * * @throw AccessControlException If access is denied * @throw FileNotFoundException If file src is not found * @throw SafeModeException create not allowed in safemode * @throw UnresolvedLinkException If src contains a symlink * @throw HdfsIOException If an I/O error occurred */ //Idempotent 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, const std::string & clientName) /* throw (AccessControlException, FileNotFoundException, SafeModeException, UnresolvedLinkException, HdfsIOException) */ = 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. * * @throw AccessControlException If access is denied * @throw FileNotFoundException If file src is not found * @throw SafeModeException create not allowed in safemode * @throw UnresolvedLinkException If src contains a symlink * @throw HdfsIOException If an I/O error occurred */ virtual bool complete(const std::string & src, const std::string & clientName, const ExtendedBlock * last) /* throw (AccessControlException, FileNotFoundException, SafeModeException, UnresolvedLinkException, HdfsIOException) */ = 0; /** * The client wants to report corrupted blocks (blocks with specified * locations on datanodes). * @param blocks Array of located blocks to report */ //Idempotent /* virtual void reportBadBlocks(const std::vector & blocks) throw (HdfsIOException) = 0;*/ /** * Rename an item in the file system namespace. * @param src existing file or directory name. * @param dst new name. * @param true if successful, or false if the old name does not exist * or if the new name already belongs to the namespace. * * @throw HdfsIOException an I/O error occurred */ virtual bool rename(const std::string & src, const std::string & dst) /* throw (UnresolvedLinkException, HdfsIOException) */ = 0; /** * Moves blocks from srcs to trg and delete srcs * * @param trg existing file * @param srcs - list of existing files (same block size, same replication) * @throw HdfsIOException if some arguments are invalid * @throw UnresolvedLinkException if trg or srcs * contains a symlink */ /* virtual void concat(const std::string & trg, const std::vector & srcs) throw (HdfsIOException, UnresolvedLinkException) = 0;*/ /** * Truncate a file to the indicated length * * @param src existing file * @param size the target size * @param clientName name of the current client. * * @return true if and client does not need to wait for block recovery, * false if client needs to wait for block recovery. * * @throws HdfsIOException if some arguments are invalid * @throws UnresolvedLinkException if f * contains a symlink */ virtual bool truncate(const std::string & src, int64_t size, const std::string & clientName) /* throw (HdfsIOException, UnresolvedLinkException) */ = 0; /** * Get the lease of the indicated file. * * @param src existing file * @param clientName name of the current client. * @throws HdfsIOException if some arguments are invalid * @throws UnresolvedLinkException if f * contains a symlink */ virtual void getLease(const std::string & src, const std::string & clientName) /* throw (HdfsIOException, UnresolvedLinkException) */ = 0; /** * Release the lease of the indicated file. * * @param src existing file * @param clientName name of the current client. * @throws HdfsIOException if some arguments are invalid * @throws UnresolvedLinkException if f * contains a symlink */ virtual void releaseLease(const std::string & src, const std::string & clientName) /* throw (HdfsIOException, UnresolvedLinkException) */ = 0; /** * Rename src to dst. *

*

* Without OVERWRITE option, rename fails if the dst already exists. * With OVERWRITE option, rename overwrites the dst, if it is a file * or an empty directory. Rename fails if dst is a non-empty directory. *

* This implementation of rename is atomic. *

* @param src existing file or directory name. * @param dst new name. * @param options Rename options * * @throw AccessControlException If access is denied * @throw DSQuotaExceededException If rename violates disk space * quota restriction * @throw FileAlreadyExistsException If dst already exists and * options has {//link Rename#OVERWRITE} option * false. * @throw FileNotFoundException If src does not exist * @throw NSQuotaExceededException If rename violates namespace * quota restriction * @throw ParentNotDirectoryException If parent of dst * is not a directory * @throw SafeModeException rename not allowed in safemode * @throw UnresolvedLinkException If src or * dst contains a symlink * @throw HdfsIOException If an I/O error occurred */ /*virtual void rename2(const std::string & src, const std::string & dst) throw (AccessControlException, DSQuotaExceededException, FileAlreadyExistsException, FileNotFoundException, NSQuotaExceededException, ParentNotDirectoryException, SafeModeException, UnresolvedLinkException, HdfsIOException) = 0;*/ /** * Delete the given file or directory from the file system. *

* same as delete but provides a way to avoid accidentally * deleting non empty directories programmatically. * @param src existing name * @param recursive if true deletes a non empty directory recursively, * else throw( an exception. * @param true only if the existing file or directory was actually removed * from the file system. * * @throw AccessControlException If access is denied * @throw FileNotFoundException If file src is not found * @throw SafeModeException create not allowed in safemode * @throw UnresolvedLinkException If src contains a symlink * @throw HdfsIOException If an I/O error occurred */ virtual bool deleteFile(const std::string & src, bool recursive) /* throw (AccessControlException, FileNotFoundException, SafeModeException, UnresolvedLinkException, HdfsIOException) */ = 0; /** * Create a directory (or hierarchy of directories) with the given * name and permission. * * @param src The path of the directory being created * @param masked The masked permission of the directory being created * @param createParent create missing parent directory if true * * @param True if the operation success. * * @throw AccessControlException If access is denied * @throw FileAlreadyExistsException If src already exists * @throw FileNotFoundException If parent of src does not exist * and createParent is false * @throw NSQuotaExceededException If file creation violates quota restriction * @throw ParentNotDirectoryException If parent of src * is not a directory * @throw SafeModeException create not allowed in safemode * @throw UnresolvedLinkException If src contains a symlink * @throw HdfsIOException If an I/O error occurred. * * RunTimeExceptions: * @throw InvalidPathException If src is invalid */ //Idempotent virtual bool mkdirs(const std::string & src, const Permission & masked, bool createParent) /* throw (AccessControlException, FileAlreadyExistsException, FileNotFoundException, NSQuotaExceededException, ParentNotDirectoryException, SafeModeException, UnresolvedLinkException, HdfsIOException) */ = 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 a partial listing starting after startAfter * @param dl append the returned directories. * * @throw AccessControlException permission denied * @throw FileNotFoundException file src is not found * @throw UnresolvedLinkException If src contains a symlink * @throw HdfsIOException If an I/O error occurred */ //Idempotent virtual bool getListing(const std::string & src, const std::string & startAfter, bool needLocation, std::vector & dl) /* throw (AccessControlException, FileNotFoundException, UnresolvedLinkException, HdfsIOException) */ = 0; /** * Client programs can cause stateful changes in the NameNode * that affect other clients. A client may obtain a file and * neither abandon nor complete it. A client might hold a series * of locks that prevent other clients from proceeding. * Clearly, it would be bad if a client held a bunch of locks * that it never gave up. This can happen easily if the client * dies unexpectedly. *

* So, the NameNode will revoke the locks and live file-creates * for clients that it thinks have died. A client tells the * NameNode that it is still alive by periodically calling * renewLease(). If a certain amount of time passes since * the last call to renewLease(), the NameNode assumes the * client has died. * * @throw AccessControlException permission denied * @throw HdfsIOException If an I/O error occurred */ //Idempotent virtual void renewLease(const std::string & clientName) /* throw (AccessControlException, HdfsIOException) */ = 0; /** * Start lease recovery. * Lightweight NameNode operation to trigger lease recovery * * @param src path of the file to start lease recovery * @param clientName name of the current client * @param true if the file is already closed * @throw HdfsIOException */ //Idempotent /* virtual bool recoverLease(const std::string & src, const std::string & clientName) throw (HdfsIOException) = 0; */ /** * Get a set of statistics about the filesystem. * Right now, only seven values are returned. *

* Use constants like {//link #GET_STATS_CAPACITY_IDX} in place of * actual numbers to index into the array. */ //Idempotent virtual std::vector getFsStats() /* throw (HdfsIOException) */ = 0; /** * Dumps namenode data structures into specified file. If the file * already exists, then append. * * @throw HdfsIOException */ /* virtual void metaSave( const std::string & filename) throw (HdfsIOException) = 0;*/ /** * Get the file info for a specific file or directory. * @param src The const std::string & representation of the path to the file * * @param exist *exist will be set to false if target file does not exist * instead of throw an exception. It can be NULL. * * @throw AccessControlException permission denied * @throw FileNotFoundException file src is not found * @throw UnresolvedLinkException if the path contains a symlink. * @throw HdfsIOException If an I/O error occurred */ //Idempotent virtual FileStatus getFileInfo(const std::string & src, bool *exist) /* throw (AccessControlException, FileNotFoundException, UnresolvedLinkException, HdfsIOException) */ = 0; /** * Get the file info for a specific file or directory. If the path * refers to a symlink then the FileStatus of the symlink is returned. * @param src The const std::string & representation of the path to the file * * @param object containing information regarding the file * or null if file not found * * @throw AccessControlException permission denied * @throw UnresolvedLinkException if src contains a symlink * @throw HdfsIOException If an I/O error occurred */ //Idempotent /* virtual FileStatus getFileLinkInfo(const std::string & src) throw (AccessControlException, UnresolvedLinkException, HdfsIOException) = 0;*/ /** * Get {//link ContentSummary} rooted at the specified directory. * @param path The const std::string & representation of the path * * @throw AccessControlException permission denied * @throw FileNotFoundException file path is not found * @throw UnresolvedLinkException if path contains a symlink. * @throw HdfsIOException If an I/O error occurred */ //Idempotent /* virtual ContentSummary getContentSummary(const std::string & path) throw (AccessControlException, FileNotFoundException, UnresolvedLinkException, HdfsIOException) = 0;*/ /** * Set the quota for a directory. * @param path The const std::string & representation of the path to the directory * @param namespaceQuota Limit on the number of names in the tree rooted * at the directory * @param diskspaceQuota Limit on disk space occupied all the files under * this directory. *

* * The quota can have three types of values : (1) 0 or more will set * the quota to that value, (2) {//link HdfsConstants#QUOTA_DONT_SET} implies * the quota will not be changed, and (3) {//link HdfsConstants#QUOTA_RESET} * implies the quota will be reset. Any other value is a runtime error. * * @throw AccessControlException permission denied * @throw FileNotFoundException file path is not found * @throw QuotaExceededException if the directory size * is greater than the given quota * @throw UnresolvedLinkException if the path contains a symlink. * @throw HdfsIOException If an I/O error occurred */ //Idempotent /* virtual void setQuota(const std::string & path, int64_t namespaceQuota, int64_t diskspaceQuota) throw (AccessControlException, FileNotFoundException, UnresolvedLinkException, HdfsIOException) = 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 * @param client The const std::string & representation of the client * * @throw AccessControlException permission denied * @throw FileNotFoundException file src is not found * @throw UnresolvedLinkException if src contains a symlink. * @throw HdfsIOException If an I/O error occurred */ //Idempotent virtual void fsync(const std::string & src, const std::string & client) /* throw (AccessControlException, FileNotFoundException, UnresolvedLinkException, HdfsIOException) */ = 0; /** * Sets the modification and access time of the file to the specified time. * @param src The const std::string & representation of the path * @param mtime The number of milliseconds since Jan 1, 1970. * Setting mtime to -1 means that modification time should not be set * by this call. * @param atime The number of milliseconds since Jan 1, 1970. * Setting atime to -1 means that access time should not be set * by this call. * * @throw AccessControlException permission denied * @throw FileNotFoundException file src is not found * @throw UnresolvedLinkException if src contains a symlink. * @throw HdfsIOException If an I/O error occurred */ //Idempotent virtual void setTimes(const std::string & src, int64_t mtime, int64_t atime) /* throw (AccessControlException, FileNotFoundException, UnresolvedLinkException, HdfsIOException) */ = 0; /** * Create symlink to a file or directory. * @param target The path of the destination that the * link points to. * @param link The path of the link being created. * @param dirPerm permissions to use when creating parent directories * @param createParent - if true then missing parent dirs are created * if false then parent must exist * * @throw AccessControlException permission denied * @throw FileAlreadyExistsException If file link already exists * @throw FileNotFoundException If parent of link does not exist * and createParent is false * @throw ParentNotDirectoryException If parent of link is not a * directory. * @throw UnresolvedLinkException if link contains a symlink. * @throw HdfsIOException If an I/O error occurred */ /* virtual void createSymlink(const std::string & target, const std::string & link, const Permission & dirPerm, bool createParent) throw (AccessControlException, FileAlreadyExistsException, FileNotFoundException, ParentNotDirectoryException, SafeModeException, UnresolvedLinkException, HdfsIOException) = 0;*/ /** * Return the target of the given symlink. If there is an intermediate * symlink in the path (ie a symlink leading up to the final path component) * then the given path is returned with this symlink resolved. * * @param path The path with a link that needs resolution. * @param The path after resolving the first symbolic link in the path. * @throw AccessControlException permission denied * @throw FileNotFoundException If path does not exist * @throw HdfsIOException If the given path does not refer to a symlink * or an I/O error occurred */ //Idempotent /* virtual std::string getLinkTarget(const std::string & path) throw (AccessControlException, FileNotFoundException, HdfsIOException) = 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 * @param clientName the name of the client * @param a located block with a new generation stamp and an access token * @param lb output the returned block. * @throw HdfsIOException if any error occurs */ //Idempotent virtual shared_ptr updateBlockForPipeline(const ExtendedBlock & block, const std::string & clientName) /* throw (HdfsIOException) */ = 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 std::string & clientName, const ExtendedBlock & oldBlock, const ExtendedBlock & newBlock, const std::vector & newNodes, const std::vector & storageIDs) /* throw (HdfsIOException) */ = 0; /** * Get a valid Delegation Token. * * @param renewer the designated renewer for the token * @return Token * @throws IOException */ virtual Token getDelegationToken(const std::string & renewer) /* throws IOException*/ = 0; /** * Renew an existing delegation token. * * @param token delegation token obtained earlier * @return the new expiration time * @throws IOException */ virtual int64_t renewDelegationToken(const Token & token) /*throws IOException*/ = 0; /** * Cancel an existing delegation token. * * @param token delegation token * @throws IOException */ virtual void cancelDelegationToken(const Token & token) /*throws IOException*/ = 0; /** * close the namenode connection. */ virtual void close() {}; /** * 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. * @throw HdfsIOException If an I/O error occurred */ virtual bool createEncryptionZone(const std::string & src, const std::string & keyName) = 0; /** * To get encryption zone information. * @param path the path which information is to be returned. * @return the encryption zone information. * @throw FileNotFoundException If file src does not exist * @throw UnresolvedLinkException If src contains a symlink * @throw HdfsIOException If an I/O error occurred */ virtual EncryptionZoneInfo getEncryptionZoneInfo(const std::string & src, bool *exist) = 0; /** * Get a partial listing of the indicated encryption zones * * @param id the index of encryption zone * @param ezl append the returned encryption zones. * * @throw AccessControlException permission denied * @throw UnresolvedLinkException If src contains a symlink * @throw HdfsIOException If an I/O error occurred */ virtual bool listEncryptionZones(const int64_t id, std::vector & ezl) /* throw (AccessControlException, UnresolvedLinkException, HdfsIOException) */ = 0; }; } } #endif /* _HDFS_LIBHDFS3_SERVER_NAMENODE_H_ */