| /** |
| * 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/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 <stdint.h> |
| #include <vector> |
| |
| 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. |
| * <p> |
| * 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. |
| * <p> |
| * 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 <code>src</code> does not exist |
| * @throw UnresolvedLinkException If <code>src</code> 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. |
| * <p> |
| * 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. |
| * <p> |
| * 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. |
| * <p> |
| * 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 <code>src</code> already exists |
| * @throw FileNotFoundException If parent of <code>src</code> does not exist |
| * and <code>createParent</code> is false |
| * @throw ParentNotDirectoryException If parent of <code>src</code> is not a |
| * directory. |
| * @throw NSQuotaExceededException If file creation violates name space |
| * quota restriction |
| * @throw SafeModeException create not allowed in safemode |
| * @throw UnresolvedLinkException If <code>src</code> contains a symlink |
| * @throw HdfsIOException If an I/O error occurred |
| * |
| * RuntimeExceptions: |
| * @throw InvalidPathException Path <code>src</code> 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 <code>src</code> is not found |
| * @throw DSQuotaExceededException If append violates disk space quota |
| * restriction |
| * @throw SafeModeException append not allowed in safemode |
| * @throw UnresolvedLinkException If <code>src</code> contains a symlink |
| * @throw HdfsIOException If an I/O error occurred. |
| * |
| * RuntimeExceptions: |
| * @throw UnsupportedOperationException if append is not supported |
| */ |
| virtual shared_ptr<LocatedBlock> append(const std::string &src, |
| const std::string &clientName) |
| /* throw (AccessControlException, |
| DSQuotaExceededException, FileNotFoundException, |
| SafeModeException, UnresolvedLinkException, HdfsIOException) */ = 0; |
| |
| /** |
| * Set replication for an existing file. |
| * <p> |
| * 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 <code>src</code> is not found |
| * @throw SafeModeException not allowed in safemode |
| * @throw UnresolvedLinkException if <code>src</code> 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 <code>src</code> is not found |
| * @throw SafeModeException not allowed in safemode |
| * @throw UnresolvedLinkException If <code>src</code> 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 <code>src</code> is not found |
| * @throw SafeModeException not allowed in safemode |
| * @throw UnresolvedLinkException If <code>src</code> 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 <code>src</code> is not found |
| * @throw UnresolvedLinkException If <code>src</code> 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 <code>src</code> 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 <code>src</code> contains a symlink |
| * @throw HdfsIOException If an I/O error occurred |
| */ |
| virtual shared_ptr<LocatedBlock> addBlock(const std::string &src, |
| const std::string &clientName, const ExtendedBlock *previous, |
| const std::vector<DatanodeInfo> &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 <code>src</code> is not found |
| * @throw SafeModeException create not allowed in safemode |
| * @throw UnresolvedLinkException If <code>src</code> contains a symlink |
| * @throw HdfsIOException If an I/O error occurred |
| */ |
| //Idempotent |
| virtual shared_ptr<LocatedBlock> getAdditionalDatanode(const std::string &src, |
| const ExtendedBlock &blk, |
| const std::vector<DatanodeInfo> &existings, |
| const std::vector<std::string> &storageIDs, |
| const std::vector<DatanodeInfo> &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 <code>src</code> is not found |
| * @throw SafeModeException create not allowed in safemode |
| * @throw UnresolvedLinkException If <code>src</code> 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<LocatedBlock> &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 <code>trg</code> or <code>srcs</code> |
| * contains a symlink |
| */ |
| /* virtual void concat(const std::string &trg, |
| const std::vector<std::string> &srcs) throw (HdfsIOException, |
| UnresolvedLinkException) = 0;*/ |
| |
| /** |
| * Rename src to dst. |
| * <ul> |
| * <li>Fails if src is a file and dst is a directory. |
| * <li>Fails if src is a directory and dst is a file. |
| * <li>Fails if the parent of dst does not exist or is a file. |
| * </ul> |
| * <p> |
| * 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. |
| * <p> |
| * This implementation of rename is atomic. |
| * <p> |
| * @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 <code>dst</code> already exists and |
| * <code>options</options> has {//link Rename#OVERWRITE} option |
| * false. |
| * @throw FileNotFoundException If <code>src</code> does not exist |
| * @throw NSQuotaExceededException If rename violates namespace |
| * quota restriction |
| * @throw ParentNotDirectoryException If parent of <code>dst</code> |
| * is not a directory |
| * @throw SafeModeException rename not allowed in safemode |
| * @throw UnresolvedLinkException If <code>src</code> or |
| * <code>dst</code> 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. |
| * <p> |
| * 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 <code>src</code> is not found |
| * @throw SafeModeException create not allowed in safemode |
| * @throw UnresolvedLinkException If <code>src</code> 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 <code>src</code> already exists |
| * @throw FileNotFoundException If parent of <code>src</code> does not exist |
| * and <code>createParent</code> is false |
| * @throw NSQuotaExceededException If file creation violates quota restriction |
| * @throw ParentNotDirectoryException If parent of <code>src</code> |
| * is not a directory |
| * @throw SafeModeException create not allowed in safemode |
| * @throw UnresolvedLinkException If <code>src</code> contains a symlink |
| * @throw HdfsIOException If an I/O error occurred. |
| * |
| * RunTimeExceptions: |
| * @throw InvalidPathException If <code>src</code> 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 <code>src</code> is not found |
| * @throw UnresolvedLinkException If <code>src</code> 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<FileStatus> &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. |
| * <p> |
| * 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) = 0; |
| |
| /** |
| * Get a set of statistics about the filesystem. |
| * Right now, only seven values are returned. |
| * <ul> |
| * <li> [0] contains the total storage capacity of the system, in bytes.</li> |
| * <li> [1] contains the total used space of the system, in bytes.</li> |
| * <li> [2] contains the available storage of the system, in bytes.</li> |
| * <li> [3] contains number of under replicated blocks in the system.</li> |
| * <li> [4] contains number of blocks with a corrupt replica. </li> |
| * <li> [5] contains number of blocks without any good replicas left. </li> |
| * </ul> |
| * Use constants like {//link #GET_STATS_CAPACITY_IDX} in place of |
| * actual numbers to index into the array. |
| */ |
| //Idempotent |
| virtual std::vector<int64_t> 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 object containing information regarding the file |
| * or null if file not found |
| * @throw AccessControlException permission denied |
| * @throw FileNotFoundException file <code>src</code> 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) |
| /* 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 <code>src</code> 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 <code>path</code> is not found |
| * @throw UnresolvedLinkException if <code>path</code> 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. |
| * <br><br> |
| * |
| * 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 <code>path</code> is not found |
| * @throw QuotaExceededException if the directory size |
| * is greater than the given quota |
| * @throw UnresolvedLinkException if the <code>path</code> 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 <code>src</code> is not found |
| * @throw UnresolvedLinkException if <code>src</code> 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 <code>src</code> is not found |
| * @throw UnresolvedLinkException if <code>src</code> 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 <code>link</code> already exists |
| * @throw FileNotFoundException If parent of <code>link</code> does not exist |
| * and <code>createParent</code> is false |
| * @throw ParentNotDirectoryException If parent of <code>link</code> is not a |
| * directory. |
| * @throw UnresolvedLinkException if <code>link</target> 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 <code>path</code> 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<LocatedBlock> 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<DatanodeInfo> &newNodes, |
| const std::vector<std::string> &storageIDs) /* throw (HdfsIOException) */ = 0; |
| |
| /** |
| * Get a valid Delegation Token. |
| * |
| * @param renewer the designated renewer for the token |
| * @return Token<DelegationTokenIdentifier> |
| * @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() {}; |
| }; |
| |
| } |
| } |
| |
| #endif /* _HDFS_LIBHDFS3_SERVER_NAMENODE_H_ */ |
