/**
 * 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_NAMENODEIMPL_H_
#define _HDFS_LIBHDFS3_SERVER_NAMENODEIMPL_H_

#include "Namenode.h"

namespace hdfs {
namespace internal {

class NamenodeImpl: public Namenode {
public:
    NamenodeImpl(const char *host, const char *port,
            const std::string &tokenService, const SessionConfig &c,
            const RpcAuth &a);

    ~NamenodeImpl();

    //Idempotent
    void getBlockLocations(const std::string &src, int64_t offset,
                           int64_t length, LocatedBlocks &lbs) /* throw (AccessControlException,
             FileNotFoundException, UnresolvedLinkException,
             HdfsIOException) */;

    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) */;

    shared_ptr<LocatedBlock> append(const std::string &src, const std::string &clientName)
    /* throw (AccessControlException,
             DSQuotaExceededException, FileNotFoundException,
             SafeModeException, UnresolvedLinkException, HdfsIOException) */;

    //Idempotent
    bool setReplication(const std::string &src, short replication)
    /* throw (AccessControlException, DSQuotaExceededException,
     FileNotFoundException, SafeModeException, UnresolvedLinkException,
     HdfsIOException) */;

    //Idempotent
    void setPermission(const std::string &src, const Permission &permission)
    /* throw (AccessControlException, FileNotFoundException,
     SafeModeException, UnresolvedLinkException, HdfsIOException) */;

    //Idempotent
    void setOwner(const std::string &src, const std::string &username,
                  const std::string &groupname) /* throw (AccessControlException,
             FileNotFoundException, SafeModeException,
             UnresolvedLinkException, HdfsIOException) */;

    void abandonBlock(const ExtendedBlock &b, const std::string &src,
                      const std::string &holder) /* throw (AccessControlException,
             FileNotFoundException, UnresolvedLinkException,
             HdfsIOException) */;

    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) */;

    //Idempotent
    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) */;

    bool complete(const std::string &src, const std::string &clientName,
                  const ExtendedBlock *last) /* throw (AccessControlException,
             FileNotFoundException, SafeModeException,
             UnresolvedLinkException, HdfsIOException) */;

    //Idempotent
    void reportBadBlocks(const std::vector<LocatedBlock> &blocks)
    /* throw (HdfsIOException) */;

    bool rename(const std::string &src, const std::string &dst)
    /* throw (UnresolvedLinkException, HdfsIOException) */;

    void concat(const std::string &trg, const std::vector<std::string> &srcs)
    /* throw (HdfsIOException, UnresolvedLinkException) */;

    /*void rename2(const std::string &src, const std::string &dst)
     throw (AccessControlException, DSQuotaExceededException,
     FileAlreadyExistsException, FileNotFoundException,
     NSQuotaExceededException, ParentNotDirectoryException,
     SafeModeException, UnresolvedLinkException, HdfsIOException) ;*/

    bool deleteFile(const std::string &src, bool recursive)
    /* throw (AccessControlException, FileNotFoundException,
     SafeModeException, UnresolvedLinkException, HdfsIOException) */;

    //Idempotent
    bool mkdirs(const std::string &src, const Permission &masked,
                bool createParent) /* throw (AccessControlException,
             FileAlreadyExistsException, FileNotFoundException,
             NSQuotaExceededException, ParentNotDirectoryException,
             SafeModeException, UnresolvedLinkException, HdfsIOException) */;

    //Idempotent
    bool getListing(const std::string &src, const std::string &startAfter,
                    bool needLocation, std::vector<FileStatus> &dl)
    /* throw (AccessControlException, FileNotFoundException,
     UnresolvedLinkException, HdfsIOException) */;

    //Idempotent
    void renewLease(const std::string &clientName)
    /* throw (AccessControlException, HdfsIOException) */;

    //Idempotent
    bool recoverLease(const std::string &src, const std::string &clientName)
    /* throw (HdfsIOException) */;

    //Idempotent
    std::vector<int64_t> getFsStats() /* throw (HdfsIOException) */;

    void metaSave(const std::string &filename) /* throw (HdfsIOException) */;

    //Idempotent
    FileStatus getFileInfo(const std::string &src)
    /* throw (AccessControlException, FileNotFoundException,
     UnresolvedLinkException, HdfsIOException) */;

    //Idempotent
    FileStatus getFileLinkInfo(const std::string &src)
    /* throw (AccessControlException, UnresolvedLinkException,
     HdfsIOException) */;

    /*    //Idempotent
        ContentSummary getContentSummary(const std::string &path)
         throw (AccessControlException, FileNotFoundException,
         UnresolvedLinkException, HdfsIOException) ;*/

    //Idempotent
    void setQuota(const std::string &path, int64_t namespaceQuota,
                  int64_t diskspaceQuota) /* throw (AccessControlException,
             FileNotFoundException, UnresolvedLinkException,
             HdfsIOException) */;

    //Idempotent
    void fsync(const std::string &src, const std::string &client)
    /* throw (AccessControlException, FileNotFoundException,
     UnresolvedLinkException, HdfsIOException) */;

    //Idempotent
    void setTimes(const std::string &src, int64_t mtime, int64_t atime)
    /* throw (AccessControlException, FileNotFoundException,
     UnresolvedLinkException, HdfsIOException) */;

    void createSymlink(const std::string &target, const std::string &link,
                       const Permission &dirPerm, bool createParent)
    /* throw (AccessControlException, FileAlreadyExistsException,
     FileNotFoundException, ParentNotDirectoryException,
     SafeModeException, UnresolvedLinkException, HdfsIOException) */;

    //Idempotent
    std::string getLinkTarget(const std::string &path)
    /* throw (AccessControlException, FileNotFoundException,
     HdfsIOException) */;

    //Idempotent
    shared_ptr<LocatedBlock> updateBlockForPipeline(const ExtendedBlock &block,
            const std::string &clientName)
    /* throw (HdfsIOException) */;

    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) */;

    //Idempotent
    Token getDelegationToken(const std::string &renewer)
    /* throws IOException*/;

    //Idempotent
    int64_t renewDelegationToken(const Token &token)
    /*throws IOException*/;

    //Idempotent
    void cancelDelegationToken(const Token &token)
    /*throws IOException*/;

private:
    void invoke(const RpcCall &call);

private:
    RpcAuth auth;
    RpcClient &client;
    RpcConfig conf;
    RpcProtocolInfo protocol;
    RpcServerInfo server;
};

}
}

#endif /* _HDFS_LIBHDFS3_SERVER_NAMENODEIMPL_H_ */