http://git-wip-us.apache.org/repos/asf/hadoop/blob/7a542fb3/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/hdfs_ext_test.cc ---------------------------------------------------------------------- diff --git a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/hdfs_ext_test.cc b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/hdfs_ext_test.cc deleted file mode 100644 index 19d95b4..0000000 --- a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/hdfs_ext_test.cc +++ /dev/null @@ -1,771 +0,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. - */ - -#include "hdfspp_mini_dfs.h" -#include "hdfspp/hdfs_ext.h" - -#include <cstring> -#include <chrono> -#include <exception> - -namespace hdfs { - -class HdfsExtTest: public ::testing::Test { -public: - MiniCluster cluster; -}; - -// Make sure we can set up a mini-cluster and connect to it -TEST_F(HdfsExtTest, TestGetBlockLocations) { - HdfsHandle connection = cluster.connect_c(); - EXPECT_NE(nullptr, connection.handle()); - - hdfsBlockLocations * blocks = nullptr; - - // Free a null pointer - int result = hdfsFreeBlockLocations(blocks); - EXPECT_EQ(0, result); - - // Test non-extant files - EXPECT_EQ(-1, hdfsGetBlockLocations(connection, "non_extant_file", &blocks)); // Should be an error - EXPECT_EQ((int) std::errc::no_such_file_or_directory, errno); - - // Test an extant file - std::string filename = connection.newFile(1024); - result = hdfsGetBlockLocations(connection, filename.c_str(), &blocks); - EXPECT_EQ(0, result); - - EXPECT_EQ(1024, blocks->fileLength); - EXPECT_EQ(1, blocks->num_blocks); - EXPECT_EQ(0, blocks->isUnderConstruction); - EXPECT_NE(0, blocks->isLastBlockComplete); - EXPECT_EQ(1024, blocks->blocks->num_bytes); - EXPECT_EQ(0, blocks->blocks->start_offset); - EXPECT_EQ(1, blocks->blocks->num_locations); - EXPECT_NE(nullptr, blocks->blocks->locations->hostname); - EXPECT_NE(nullptr, blocks->blocks->locations->ip_address); - EXPECT_NE(nullptr, blocks->blocks->locations->network_location); - EXPECT_NE(0, blocks->blocks->locations->xfer_port); - - result = hdfsFreeBlockLocations(blocks); - EXPECT_EQ(0, result); - -} - - -// Writing a file to the filesystem and checking the used space -TEST_F(HdfsExtTest, TestGetUsed) { - using namespace std::chrono; - - HdfsHandle connection = cluster.connect_c(); - hdfsFS fs = connection.handle(); - EXPECT_NE(nullptr, fs); - - // File system's used space before writing - tOffset used_before_write; - EXPECT_GE(used_before_write = hdfsGetUsed(fs), 0); - - // Write to a file - tOffset fileSize = 1024; - std::string filename = connection.newFile(fileSize); - - //Need to run hdfsGetUsed() in a loop until the refreshInterval - //is passed on the filesystem and the used space is updated - //Time-out is 3 minutes - tOffset used_after_write; - tOffset difference; - minutes beginTime = duration_cast<minutes>( - system_clock::now().time_since_epoch()); - minutes currentTime; - do{ - EXPECT_GE(used_after_write = hdfsGetUsed(fs), 0); - difference = used_after_write - used_before_write; - currentTime = duration_cast<minutes>( - system_clock::now().time_since_epoch()); - } while (difference == 0 && currentTime.count() - beginTime.count() < 3); - - //There should be at least fileSize bytes added to the used space - EXPECT_GT(difference, fileSize); - //There could be additional metadata added to the used space, - //but no more than double the fileSize - EXPECT_LT(difference, fileSize * 2); - -} - - -//Testing allow, disallow, create, and delete snapshot -TEST_F(HdfsExtTest, TestSnapshotOperations) { - HdfsHandle connection = cluster.connect_c(); - hdfsFS fs = connection.handle(); - EXPECT_NE(nullptr, fs); - - //argument 'path' is NULL - EXPECT_EQ(-1, hdfsAllowSnapshot(fs, nullptr)); - EXPECT_EQ((int) std::errc::invalid_argument, errno); - EXPECT_EQ(-1, hdfsCreateSnapshot(fs, nullptr, "Bad")); - EXPECT_EQ((int) std::errc::invalid_argument, errno); - EXPECT_EQ(-1, hdfsDeleteSnapshot(fs, nullptr, "Bad")); - EXPECT_EQ((int) std::errc::invalid_argument, errno); - EXPECT_EQ(-1, hdfsRenameSnapshot(fs, nullptr, "Bad", "Bad")); - EXPECT_EQ((int) std::errc::invalid_argument, errno); - EXPECT_EQ(-1, hdfsDisallowSnapshot(fs, nullptr)); - EXPECT_EQ((int) std::errc::invalid_argument, errno); - - //argument 'name' is NULL for deletion - EXPECT_EQ(-1, hdfsDeleteSnapshot(fs, "/dir/", nullptr)); - EXPECT_EQ((int) std::errc::invalid_argument, errno); - - //Path not found - std::string path = "/wrong/dir/"; - EXPECT_EQ(-1, hdfsAllowSnapshot(fs, path.c_str())); - EXPECT_EQ((int) std::errc::no_such_file_or_directory, errno); - EXPECT_EQ(-1, hdfsCreateSnapshot(fs, path.c_str(), "Bad")); - EXPECT_EQ((int) std::errc::no_such_file_or_directory, errno); - EXPECT_EQ(-1, hdfsDeleteSnapshot(fs, path.c_str(), "Bad")); - EXPECT_EQ((int) std::errc::no_such_file_or_directory, errno); - EXPECT_EQ(-1, hdfsRenameSnapshot(fs, path.c_str(), "Bad", "Bad")); - EXPECT_EQ((int) std::errc::no_such_file_or_directory, errno); - EXPECT_EQ(-1, hdfsDisallowSnapshot(fs, path.c_str())); - EXPECT_EQ((int) std::errc::no_such_file_or_directory, errno); - - //Not a directory - path = connection.newFile(1024); //1024 byte file - EXPECT_EQ(-1, hdfsAllowSnapshot(fs, path.c_str())); - EXPECT_EQ((int) std::errc::not_a_directory, errno); - EXPECT_EQ(-1, hdfsCreateSnapshot(fs, path.c_str(), "Bad")); - EXPECT_EQ((int) std::errc::not_a_directory, errno); - EXPECT_EQ(-1, hdfsDeleteSnapshot(fs, path.c_str(), "Bad")); - EXPECT_EQ((int) std::errc::not_a_directory, errno); - EXPECT_EQ(-1, hdfsRenameSnapshot(fs, path.c_str(), "Bad", "Bad")); - EXPECT_EQ((int) std::errc::not_a_directory, errno); - EXPECT_EQ(-1, hdfsDisallowSnapshot(fs, path.c_str())); - EXPECT_EQ((int) std::errc::not_a_directory, errno); - - //Not snapshottable directory - std::string dirName = connection.newDir(); - EXPECT_EQ(0, hdfsDisallowSnapshot(fs, dirName.c_str())); - EXPECT_EQ(-1, hdfsCreateSnapshot(fs, dirName.c_str(), "Bad")); - EXPECT_EQ((int) std::errc::invalid_argument, errno); - - //Verify snapshot created - EXPECT_EQ(0, hdfsAllowSnapshot(fs, dirName.c_str())); - EXPECT_EQ(0, hdfsCreateSnapshot(fs, dirName.c_str(), "Good")); - std::string snapDir = dirName + ".snapshot/"; - int size; - hdfsFileInfo *file_infos; - EXPECT_NE(nullptr, file_infos = hdfsListDirectory(fs, snapDir.c_str(), &size)); - EXPECT_EQ(1, size); - EXPECT_STREQ("Good", file_infos[0].mName); - hdfsFreeFileInfo(file_infos, 1); - - //Verify snapshot renamed - EXPECT_EQ(0, hdfsRenameSnapshot(fs, dirName.c_str(), "Good", "Best")); - - //Verify snapshot deleted - EXPECT_EQ(0, hdfsDeleteSnapshot(fs, dirName.c_str(), "Best")); - EXPECT_EQ(nullptr, file_infos = hdfsListDirectory(fs, snapDir.c_str(), &size)); - EXPECT_EQ(0, size); - hdfsFreeFileInfo(file_infos, 0); -} - -//Testing creating directories -TEST_F(HdfsExtTest, TestMkdirs) { - HdfsHandle connection = cluster.connect_c(); - hdfsFS fs = connection.handle(); - EXPECT_NE(nullptr, fs); - - //Correct operation - EXPECT_EQ(0, hdfsCreateDirectory(fs, "/myDir123")); - - //TODO Should return error if directory already exists? - //EXPECT_EQ(-1, hdfsCreateDirectory(fs, "/myDir123")); - //EXPECT_EQ((int) std::errc::file_exists, errno); - - //Creating directory on a path of the existing file - std::string path = connection.newFile(1024); //1024 byte file - EXPECT_EQ(-1, hdfsCreateDirectory(fs, path.c_str())); - EXPECT_EQ((int) std::errc::file_exists, errno); -} - -//Testing deleting files and directories -TEST_F(HdfsExtTest, TestDelete) { - HdfsHandle connection = cluster.connect_c(); - hdfsFS fs = connection.handle(); - EXPECT_NE(nullptr, fs); - - //Path not found - EXPECT_EQ(-1, hdfsDelete(fs, "/wrong_path", 1)); - EXPECT_EQ((int) std::errc::no_such_file_or_directory, errno); - - EXPECT_EQ(0, hdfsCreateDirectory(fs, "/myDir")); - std::string path = connection.newFile("/myDir", 1024); //1024 byte file - - //Non-recursive delete should fail on a non-empty directory - //error ENOTEMPTY(39) for libhdfspp or 255 for libhdfs - EXPECT_EQ(-1, hdfsDelete(fs, "/myDir", 0)); - EXPECT_EQ((int) std::errc::directory_not_empty, errno); - - //Correct operation - EXPECT_EQ(0, hdfsDelete(fs, "/myDir", 1)); -} - -//Testing renaming files and directories -TEST_F(HdfsExtTest, TestRename) { - HdfsHandle connection = cluster.connect_c(); - hdfsFS fs = connection.handle(); - EXPECT_NE(nullptr, fs); - - //Creating directory with two files - EXPECT_EQ(0, hdfsCreateDirectory(fs, "/myDir")); - std::string file1 = connection.newFile("/myDir", 1024); //1024 byte file - std::string file2 = connection.newFile("/myDir", 1024); //1024 byte file - std::string file3 = connection.newFile(1024); //1024 byte file - - //Path not found - EXPECT_EQ(-1, hdfsRename(fs, "/wrong_path", "/new_name")); - EXPECT_EQ((int) std::errc::invalid_argument, errno); - - //No parent directory in new path - EXPECT_EQ(-1, hdfsRename(fs, file1.c_str(), "/wrong_parent/new_name")); - EXPECT_EQ((int ) std::errc::invalid_argument, errno); - - //New name already exists in the folder - EXPECT_EQ(-1, hdfsRename(fs, file1.c_str(), file2.c_str())); - EXPECT_EQ((int ) std::errc::invalid_argument, errno); - - //Correct operation - EXPECT_EQ(0, hdfsRename(fs, file1.c_str(), "/myDir/new_awesome_name")); - EXPECT_EQ(0, hdfsRename(fs, file3.c_str(), "/myDir/another_file")); - EXPECT_EQ(0, hdfsRename(fs, "/myDir", "/new_awesome_dir")); - - //Verification - int numEntries; - hdfsFileInfo * dirList = hdfsListDirectory(fs, "/new_awesome_dir", &numEntries); - EXPECT_NE(nullptr, dirList); - EXPECT_EQ(3, numEntries); - hdfsFreeFileInfo(dirList, 3); -} - -//Testing Chmod and Chown -TEST_F(HdfsExtTest, TestChmodChown) { - HdfsHandle connection = cluster.connect_c(); - hdfsFS fs = connection.handle(); - EXPECT_NE(nullptr, fs); - - //Path not found - std::string path = "/wrong/dir/"; - EXPECT_EQ(-1, hdfsChmod(fs, path.c_str(), 0777)); - EXPECT_EQ((int ) std::errc::no_such_file_or_directory, errno); - EXPECT_EQ(-1, hdfsChown(fs, path.c_str(), "foo", "bar")); - EXPECT_EQ((int ) std::errc::no_such_file_or_directory, errno); - - //Wrong arguments - path = connection.newFile(1024); //1024 byte file - EXPECT_EQ(-1, hdfsChmod(fs, nullptr, 0777)); - EXPECT_EQ((int ) std::errc::invalid_argument, errno); - EXPECT_EQ(-1, hdfsChmod(fs, path.c_str(), 07777)); - EXPECT_EQ((int ) std::errc::invalid_argument, errno); - EXPECT_EQ(-1, hdfsChmod(fs, path.c_str(), -1)); - EXPECT_EQ((int ) std::errc::invalid_argument, errno); - EXPECT_EQ(-1, hdfsChown(fs, nullptr, "foo", "bar")); - EXPECT_EQ((int ) std::errc::invalid_argument, errno); - - //Permission denied - HdfsHandle connection2 = cluster.connect_c("OtherGuy"); - hdfsFS fs2 = connection2.handle(); - EXPECT_EQ(-1, hdfsChmod(fs2, path.c_str(), 0123)); - EXPECT_EQ((int ) std::errc::permission_denied, errno); - EXPECT_EQ(-1, hdfsChown(fs2, path.c_str(), "cool", "nice")); - EXPECT_EQ((int ) std::errc::permission_denied, errno); - - //Verify Chmod and Chown worked - EXPECT_EQ(0, hdfsChmod(fs, path.c_str(), 0123)); - EXPECT_EQ(0, hdfsChown(fs, path.c_str(), "cool", "nice")); - hdfsFileInfo *file_info; - EXPECT_NE(nullptr, file_info = hdfsGetPathInfo(fs, path.c_str())); - EXPECT_EQ(0123, file_info->mPermissions); - EXPECT_STREQ("cool", file_info->mOwner); - EXPECT_STREQ("nice", file_info->mGroup); - hdfsFreeFileInfo(file_info, 1); -} - -//Testing EOF -TEST_F(HdfsExtTest, TestEOF) { - HdfsHandle connection = cluster.connect_c(); - hdfsFS fs = connection.handle(); - EXPECT_NE(nullptr, fs); - //Write to a file - errno = 0; - int size = 256; - std::string path = "/eofTest"; - hdfsFile file = hdfsOpenFile(fs, path.c_str(), O_WRONLY, 0, 0, 0); - EXPECT_NE(nullptr, file); - void * buf = malloc(size); - memset(buf, ' ', size); - EXPECT_EQ(size, hdfsWrite(fs, file, buf, size)); - free(buf); - EXPECT_EQ(0, hdfsCloseFile(fs, file)); - //libhdfs file operations work, but sometimes sets errno ENOENT : 2 - - //Test normal reading (no EOF) - char buffer[300]; - file = hdfsOpenFile(fs, path.c_str(), O_RDONLY, 0, 0, 0); - EXPECT_EQ(size, hdfsPread(fs, file, 0, buffer, sizeof(buffer))); - //Read executes correctly, but causes a warning (captured in HDFS-10595) - //and sets errno to EINPROGRESS 115 : Operation now in progress - - //Test reading at offset past the EOF - EXPECT_EQ(-1, hdfsPread(fs, file, sizeof(buffer), buffer, sizeof(buffer))); - EXPECT_EQ(Status::kInvalidOffset, errno); - - EXPECT_EQ(0, hdfsCloseFile(fs, file)); -} - -//Testing hdfsExists -TEST_F(HdfsExtTest, TestExists) { - - HdfsHandle connection = cluster.connect_c(); - hdfsFS fs = connection.handle(); - EXPECT_NE(nullptr, fs); - //Path not found - EXPECT_EQ(-1, hdfsExists(fs, "/wrong/dir/")); - EXPECT_EQ((int ) std::errc::no_such_file_or_directory, errno); - - //Correct operation - std::string pathDir = "/testExistsDir"; - EXPECT_EQ(0, hdfsCreateDirectory(fs, pathDir.c_str())); - EXPECT_EQ(0, hdfsExists(fs, pathDir.c_str())); - std::string pathFile = connection.newFile(pathDir.c_str(), 1024); - EXPECT_EQ(0, hdfsExists(fs, pathFile.c_str())); - - //Permission denied - EXPECT_EQ(0, hdfsChmod(fs, pathDir.c_str(), 0700)); - HdfsHandle connection2 = cluster.connect_c("OtherGuy"); - hdfsFS fs2 = connection2.handle(); - EXPECT_EQ(-1, hdfsExists(fs2, pathFile.c_str())); - EXPECT_EQ((int ) std::errc::permission_denied, errno); -} - -//Testing Replication and Time modifications -TEST_F(HdfsExtTest, TestReplAndTime) { - HdfsHandle connection = cluster.connect_c(); - hdfsFS fs = connection.handle(); - EXPECT_NE(nullptr, fs); - - std::string path = "/wrong/dir/"; - - //Path not found - EXPECT_EQ(-1, hdfsSetReplication(fs, path.c_str(), 3)); - EXPECT_EQ((int ) std::errc::no_such_file_or_directory, errno); - EXPECT_EQ(-1, hdfsUtime(fs, path.c_str(), 1000000, 1000000)); - EXPECT_EQ((int ) std::errc::no_such_file_or_directory, errno); - - //Correct operation - path = connection.newFile(1024); - EXPECT_EQ(0, hdfsSetReplication(fs, path.c_str(), 7)); - EXPECT_EQ(0, hdfsUtime(fs, path.c_str(), 123456789, 987654321)); - hdfsFileInfo *file_info; - EXPECT_NE(nullptr, file_info = hdfsGetPathInfo(fs, path.c_str())); - EXPECT_EQ(7, file_info->mReplication); - EXPECT_EQ(123456789, file_info->mLastMod); - EXPECT_EQ(987654321, file_info->mLastAccess); - hdfsFreeFileInfo(file_info, 1); - - //Wrong arguments - EXPECT_EQ(-1, hdfsSetReplication(fs, path.c_str(), 0)); - EXPECT_EQ((int ) std::errc::invalid_argument, errno); - EXPECT_EQ(-1, hdfsSetReplication(fs, path.c_str(), 513)); - EXPECT_EQ((int ) std::errc::invalid_argument, errno); - - //Permission denied - EXPECT_EQ(0, hdfsChmod(fs, path.c_str(), 0700)); - HdfsHandle connection2 = cluster.connect_c("OtherGuy"); - hdfsFS fs2 = connection2.handle(); - EXPECT_EQ(-1, hdfsSetReplication(fs2, path.c_str(), 3)); - EXPECT_EQ((int ) std::errc::permission_denied, errno); - EXPECT_EQ(-1, hdfsUtime(fs2, path.c_str(), 111111111, 222222222)); - EXPECT_EQ((int ) std::errc::permission_denied, errno); -} - -//Testing getting default block size at path -TEST_F(HdfsExtTest, TestDefaultBlockSize) { - HdfsHandle connection = cluster.connect_c(); - hdfsFS fs = connection.handle(); - EXPECT_NE(nullptr, fs); - - //Correct operation (existing path) - std::string path = connection.newFile(1024); - long block_size = hdfsGetDefaultBlockSizeAtPath(fs, path.c_str()); - EXPECT_GT(block_size, 0); - hdfsFileInfo *file_info; - EXPECT_NE(nullptr, file_info = hdfsGetPathInfo(fs, path.c_str())); - EXPECT_EQ(block_size, file_info->mBlockSize); - hdfsFreeFileInfo(file_info, 1); - - //Non-existing path - path = "/wrong/dir/"; - EXPECT_GT(hdfsGetDefaultBlockSizeAtPath(fs, path.c_str()), 0); - - //No path specified - EXPECT_GT(hdfsGetDefaultBlockSize(fs), 0); -} - -//Testing getting hosts -TEST_F(HdfsExtTest, TestHosts) { - HdfsHandle connection = cluster.connect_c(); - hdfsFS fs = connection.handle(); - EXPECT_NE(nullptr, fs); - - char *** hosts = nullptr; - - // Free a null pointer - hdfsFreeHosts(hosts); - EXPECT_EQ(0, errno); - - // Test non-existent files - EXPECT_EQ(nullptr, hdfsGetHosts(fs, "/wrong/file/", 0, std::numeric_limits<int64_t>::max())); - EXPECT_EQ((int ) std::errc::no_such_file_or_directory, errno); - - // Test an existent file - std::string filename = connection.newFile(1024); - EXPECT_NE(nullptr, hosts = hdfsGetHosts(fs, filename.c_str(), 0, std::numeric_limits<int64_t>::max())); - - //Make sure there is at least one host - EXPECT_NE(nullptr, *hosts); - EXPECT_NE(nullptr, **hosts); - - hdfsFreeHosts(hosts); - EXPECT_EQ(0, errno); - - //Test invalid arguments - EXPECT_EQ(nullptr, hdfsGetHosts(fs, filename.c_str(), 0, std::numeric_limits<int64_t>::max()+1)); - EXPECT_EQ((int) std::errc::invalid_argument, errno); - - //Test invalid arguments - EXPECT_EQ(nullptr, hdfsGetHosts(fs, filename.c_str(), std::numeric_limits<int64_t>::max()+1, std::numeric_limits<int64_t>::max())); - EXPECT_EQ((int) std::errc::invalid_argument, errno); -} - -//Testing read statistics -TEST_F(HdfsExtTest, TestReadStats) { - HdfsHandle connection = cluster.connect_c(); - hdfsFS fs = connection.handle(); - EXPECT_NE(nullptr, fs); - - struct hdfsReadStatistics *stats; - - //Write to a file - int size = 256; - std::string path = "/readStatTest"; - hdfsFile file = hdfsOpenFile(fs, path.c_str(), O_WRONLY, 0, 0, 0); - EXPECT_NE(nullptr, file); - void * buf = malloc(size); - bzero(buf, size); - EXPECT_EQ(size, hdfsWrite(fs, file, buf, size)); - free(buf); - EXPECT_EQ(0, hdfsCloseFile(fs, file)); - - //test before reading - file = hdfsOpenFile(fs, path.c_str(), O_RDONLY, 0, 0, 0); - EXPECT_EQ(0, hdfsFileGetReadStatistics(file, &stats)); - EXPECT_EQ(0, stats->totalBytesRead); - hdfsFileFreeReadStatistics(stats); - - //test after reading - char buffer[123]; - //Read executes correctly, but causes a warning (captured in HDFS-10595) - EXPECT_EQ(sizeof(buffer), hdfsRead(fs, file, buffer, sizeof(buffer))); - EXPECT_EQ(0, hdfsFileGetReadStatistics(file, &stats)); - EXPECT_EQ(sizeof(buffer), stats->totalBytesRead); - EXPECT_EQ(sizeof(buffer), stats->totalLocalBytesRead); - EXPECT_EQ(0, hdfsReadStatisticsGetRemoteBytesRead(stats)); - hdfsFileFreeReadStatistics(stats); - - //test after clearing - EXPECT_EQ(0, hdfsFileClearReadStatistics(file)); - EXPECT_EQ(0, hdfsFileGetReadStatistics(file, &stats)); - EXPECT_EQ(0, stats->totalBytesRead); - hdfsFileFreeReadStatistics(stats); - - EXPECT_EQ(0, hdfsCloseFile(fs, file)); - EXPECT_EQ(0, errno); -} - -//Testing working directory -TEST_F(HdfsExtTest, TestWorkingDirectory) { - HdfsHandle connection = cluster.connect_c(); - hdfsFS fs = connection.handle(); - EXPECT_NE(nullptr, fs); - - //Correct operation of setter and getter - std::string pathDir = "/testWorkDir/"; - EXPECT_EQ(0, hdfsCreateDirectory(fs, pathDir.c_str())); - std::string pathFile = connection.newFile(pathDir.c_str(), 1024); - EXPECT_EQ(0, hdfsSetWorkingDirectory(fs, pathDir.c_str())); - char array[100]; - EXPECT_STREQ(pathDir.c_str(), hdfsGetWorkingDirectory(fs, array, 100)); - - //Get relative path - std::size_t slashPos = pathFile.find_last_of("/"); - std::string fileName = pathFile.substr(slashPos + 1); - - //Testing various functions with relative path: - - //hdfsGetDefaultBlockSizeAtPath - EXPECT_GT(hdfsGetDefaultBlockSizeAtPath(fs, fileName.c_str()), 0); - - //hdfsSetReplication - EXPECT_EQ(0, hdfsSetReplication(fs, fileName.c_str(), 7)); - - //hdfsUtime - EXPECT_EQ(0, hdfsUtime(fs, fileName.c_str(), 123456789, 987654321)); - - //hdfsExists - EXPECT_EQ(0, hdfsExists(fs, fileName.c_str())); - - //hdfsGetPathInfo - hdfsFileInfo *file_info; - EXPECT_NE(nullptr, file_info = hdfsGetPathInfo(fs, fileName.c_str())); - hdfsFreeFileInfo(file_info, 1); - - //hdfsOpenFile - hdfsFile file; - file = hdfsOpenFile(fs, fileName.c_str(), O_RDONLY, 0, 0, 0); - EXPECT_EQ(0, hdfsCloseFile(fs, file)); - - //hdfsCreateDirectory - EXPECT_EQ(0, hdfsCreateDirectory(fs, "newDir")); - - //add another file - std::string fileName2 = connection.newFile(pathDir + "/newDir", 1024); - - //hdfsListDirectory - int numEntries; - hdfsFileInfo * dirList; - EXPECT_NE(nullptr, dirList = hdfsListDirectory(fs, "newDir", &numEntries)); - EXPECT_EQ(1, numEntries); - hdfsFreeFileInfo(dirList, 1); - - //hdfsChmod - EXPECT_EQ(0, hdfsChmod(fs, fileName.c_str(), 0777)); - - //hdfsChown - EXPECT_EQ(0, hdfsChown(fs, fileName.c_str(), "cool", "nice")); - - //hdfsDisallowSnapshot - EXPECT_EQ(0, hdfsDisallowSnapshot(fs, "newDir")); - - //hdfsAllowSnapshot - EXPECT_EQ(0, hdfsAllowSnapshot(fs, "newDir")); - - //hdfsCreateSnapshot - EXPECT_EQ(0, hdfsCreateSnapshot(fs, "newDir", "Some")); - - //hdfsDeleteSnapshot - EXPECT_EQ(0, hdfsDeleteSnapshot(fs, "newDir", "Some")); - - //hdfsGetBlockLocations - hdfsBlockLocations * blocks = nullptr; - EXPECT_EQ(0, hdfsGetBlockLocations(connection, fileName.c_str(), &blocks)); - hdfsFreeBlockLocations(blocks); - - //hdfsGetHosts - char *** hosts; - EXPECT_NE(nullptr, hosts = hdfsGetHosts(fs, fileName.c_str(), 0, std::numeric_limits<int64_t>::max())); - hdfsFreeHosts(hosts); - - //hdfsRename - EXPECT_EQ(0, hdfsRename(fs, fileName.c_str(), "new_file_name")); - - //hdfsDelete - EXPECT_EQ(0, hdfsDelete(fs, "new_file_name", 0)); -} - - -// Flags used to test event handlers -static int connect_callback_invoked = 0; -int basic_fs_callback(const char *event, const char *cluster, int64_t value, int64_t cookie) { - (void)cluster; - (void)value; - if(::strstr(FS_NN_CONNECT_EVENT, event) && cookie == 0xFFF0) { - connect_callback_invoked = 1; - } - return LIBHDFSPP_EVENT_OK; -} - -// Make sure event handler gets called during connect -TEST_F(HdfsExtTest, TestConnectEvent) { - connect_callback_invoked = 0; - hdfsPreAttachFSMonitor(basic_fs_callback, 0xFFF0); - - HdfsHandle connection = cluster.connect_c(); - hdfsFS fs = connection.handle(); - EXPECT_NE(nullptr, fs); - EXPECT_EQ(connect_callback_invoked, 1); -} - -int throwing_fs_callback(const char *event, const char *cluster, int64_t value, int64_t cookie) { - (void)cluster; - (void)value; - if(::strstr(FS_NN_CONNECT_EVENT, event) && cookie == 0xFFF1) { - connect_callback_invoked = 1; - throw std::runtime_error("Throwing in callbacks is a bad thing."); - } - return LIBHDFSPP_EVENT_OK; -} - -// Make sure throwing in the connect event handler doesn't prevent connection -TEST_F(HdfsExtTest, TestConnectEventThrow) { - connect_callback_invoked = 0; - hdfsPreAttachFSMonitor(throwing_fs_callback, 0xFFF1); - - HdfsHandle connection = cluster.connect_c(); - hdfsFS fs = connection.handle(); - EXPECT_NE(nullptr, fs); - EXPECT_EQ(connect_callback_invoked, 1); -} - -int char_throwing_fs_callback(const char *event, const char *cluster, int64_t value, int64_t cookie) { - (void)cluster; - (void)value; - if(::strstr(FS_NN_CONNECT_EVENT, event) && cookie == 0xFFF2) { - connect_callback_invoked = 1; - throw "Throwing non std::exceptions in callbacks is even worse."; - } - return LIBHDFSPP_EVENT_OK; -} - -TEST_F(HdfsExtTest, TestConnectEventThrowChar) { - connect_callback_invoked = 0; - hdfsPreAttachFSMonitor(char_throwing_fs_callback, 0xFFF2); - - HdfsHandle connection = cluster.connect_c(); - hdfsFS fs = connection.handle(); - EXPECT_NE(nullptr, fs); - EXPECT_EQ(connect_callback_invoked, 1); -} - -// Make sure throwing in the read event handler doesn't prevent reads -int read_handler_invokation_count = 0; -int basic_read_event_handler(const char *event, const char *cluster, const char *file, - int64_t value, int64_t cookie) -{ - (void)cluster; - (void)file; - (void)value; - if(::strstr(FILE_DN_READ_EVENT, event) && cookie == 0xFFF3) { - read_handler_invokation_count += 1; - } - return LIBHDFSPP_EVENT_OK; -} - -// Testing that read handler is called. -// Note: This is counting calls to async_read rather than hdfsPread. -// Typically a call to hdfs(P)Read that doesn't span blocks/packets -// invokes async_read 6 times; 4 more than required (improving that -// in HDFS-11266). -TEST_F(HdfsExtTest, TestReadEvent) { - read_handler_invokation_count = 0; - hdfsPreAttachFileMonitor(basic_read_event_handler, 0xFFF3); - - HdfsHandle connection = cluster.connect_c(); - hdfsFS fs = connection.handle(); - EXPECT_NE(nullptr, fs); - //Write to a file - errno = 0; - int size = 256; - std::string path = "/readEventTest"; - hdfsFile file = hdfsOpenFile(fs, path.c_str(), O_WRONLY, 0, 0, 0); - EXPECT_NE(nullptr, file); - void * buf = malloc(size); - memset(buf, ' ', size); - EXPECT_EQ(size, hdfsWrite(fs, file, buf, size)); - free(buf); - EXPECT_EQ(0, hdfsCloseFile(fs, file)); - - //Test that read counters are getting incremented - char buffer[300]; - file = hdfsOpenFile(fs, path.c_str(), O_RDONLY, 0, 0, 0); - EXPECT_EQ(size, hdfsPread(fs, file, 0, buffer, sizeof(buffer))); - EXPECT_EQ(read_handler_invokation_count, 6); - - EXPECT_EQ(size, hdfsPread(fs, file, 0, buffer, sizeof(buffer))); - EXPECT_EQ(read_handler_invokation_count, 12); - - - EXPECT_EQ(0, hdfsCloseFile(fs, file)); -} - -int throwing_read_event_handler(const char *event, const char *cluster, const char *file, - int64_t value, int64_t cookie) -{ - (void)cluster; - (void)file; - (void)value; - if(::strstr(FILE_DN_READ_EVENT, event) && cookie == 0xFFF4) { - read_handler_invokation_count += 1; - throw std::runtime_error("Throwing here is a bad idea, but shouldn't break reads"); - } - return LIBHDFSPP_EVENT_OK; -} - -// Testing that reads can be done when event handler throws. -TEST_F(HdfsExtTest, TestReadEventThrow) { - read_handler_invokation_count = 0; - hdfsPreAttachFileMonitor(throwing_read_event_handler, 0xFFF4); - - HdfsHandle connection = cluster.connect_c(); - hdfsFS fs = connection.handle(); - EXPECT_NE(nullptr, fs); - //Write to a file - errno = 0; - int size = 256; - std::string path = "/readEventTest"; - hdfsFile file = hdfsOpenFile(fs, path.c_str(), O_WRONLY, 0, 0, 0); - EXPECT_NE(nullptr, file); - void * buf = malloc(size); - memset(buf, ' ', size); - EXPECT_EQ(size, hdfsWrite(fs, file, buf, size)); - free(buf); - EXPECT_EQ(0, hdfsCloseFile(fs, file)); - - //Test that read counters are getting incremented - char buffer[300]; - file = hdfsOpenFile(fs, path.c_str(), O_RDONLY, 0, 0, 0); - EXPECT_EQ(size, hdfsPread(fs, file, 0, buffer, sizeof(buffer))); - EXPECT_EQ(read_handler_invokation_count, 6); - - EXPECT_EQ(size, hdfsPread(fs, file, 0, buffer, sizeof(buffer))); - EXPECT_EQ(read_handler_invokation_count, 12); - - - EXPECT_EQ(0, hdfsCloseFile(fs, file)); -} - - -} // end namespace hdfs - -int main(int argc, char *argv[]) { - // The following line must be executed to initialize Google Mock - // (and Google Test) before running the tests. - ::testing::InitGoogleMock(&argc, argv); - int exit_code = RUN_ALL_TESTS(); - google::protobuf::ShutdownProtobufLibrary(); - - return exit_code; -}
http://git-wip-us.apache.org/repos/asf/hadoop/blob/7a542fb3/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/hdfs_ioservice_test.cc ---------------------------------------------------------------------- diff --git a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/hdfs_ioservice_test.cc b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/hdfs_ioservice_test.cc deleted file mode 100644 index 5ee9789..0000000 --- a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/hdfs_ioservice_test.cc +++ /dev/null @@ -1,105 +0,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. - */ - -#include "common/hdfs_ioservice.h" - -#include <future> -#include <functional> -#include <thread> -#include <string> - -#include <gmock/gmock.h> - -using ::testing::_; -using ::testing::InvokeArgument; -using ::testing::Return; - -using namespace hdfs; - -// Make sure IoService spins up specified number of threads -TEST(IoServiceTest, InitThreads) { -#ifndef DISABLE_CONCURRENT_WORKERS - std::shared_ptr<IoServiceImpl> service = std::static_pointer_cast<IoServiceImpl>(IoService::MakeShared()); - EXPECT_NE(service, nullptr); - - unsigned int thread_count = 4; - unsigned int result_thread_count = service->InitWorkers(thread_count); - EXPECT_EQ(thread_count, result_thread_count); - - service->Stop(); -#else - #pragma message("DISABLE_CONCURRENT_WORKERS is defined so hdfs_ioservice_test will compile out the InitThreads test") -#endif -} - -// Make sure IoService defaults to logical thread count -TEST(IoServiceTest, InitDefaultThreads) { -#ifndef DISABLE_CONCURRENT_WORKERS - std::shared_ptr<IoServiceImpl> service = std::static_pointer_cast<IoServiceImpl>(IoService::MakeShared()); - EXPECT_NE(service, nullptr); - - unsigned int thread_count = std::thread::hardware_concurrency(); - unsigned int result_thread_count = service->InitDefaultWorkers(); - EXPECT_EQ(thread_count, result_thread_count); - - service->Stop(); -#else - #pragma message("DISABLE_CONCURRENT_WORKERS is defined so hdfs_ioservice_test will compile out the InitDefaultThreads test") -#endif -} - - -// Check IoService::PostTask -TEST(IoServiceTest, SimplePost) { - std::shared_ptr<IoServiceImpl> service = std::static_pointer_cast<IoServiceImpl>(IoService::MakeShared()); - EXPECT_NE(service, nullptr); - - unsigned int thread_count = std::thread::hardware_concurrency(); - unsigned int result_thread_count = service->InitDefaultWorkers(); -#ifndef DISABLE_CONCURRENT_WORKERS - EXPECT_EQ(thread_count, result_thread_count); -#else - (void)thread_count; - (void)result_thread_count; -#endif - // Like with the C synchronous shims a promise/future is needed to block until the async call completes. - auto promise = std::make_shared<std::promise<std::string>>(); - std::future<std::string> future = promise->get_future(); - - // this will get invoked on a worker thread - std::function<void()> example_callback = [promise](){ - promise->set_value("hello from IoService"); - }; - service->PostTask(example_callback); - - // block until worker thread finishes - std::string result = future.get(); - EXPECT_EQ(result, "hello from IoService"); - - service->Stop(); - -} - -int main(int argc, char *argv[]) { - // The following line must be executed to initialize Google Mock - // (and Google Test) before running the tests. - ::testing::InitGoogleMock(&argc, argv); - int exit_code = RUN_ALL_TESTS(); - google::protobuf::ShutdownProtobufLibrary(); - return exit_code; -} http://git-wip-us.apache.org/repos/asf/hadoop/blob/7a542fb3/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/hdfs_shim.c ---------------------------------------------------------------------- diff --git a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/hdfs_shim.c b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/hdfs_shim.c deleted file mode 100644 index 54d4cf6..0000000 --- a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/hdfs_shim.c +++ /dev/null @@ -1,524 +0,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. - */ - -#include "libhdfs_wrapper.h" -#include "libhdfspp_wrapper.h" -#include "hdfs/hdfs.h" - -#include <stdio.h> -#include <stdlib.h> -#include <string.h> - -/* Shim structs and functions that delegate to libhdfspp and libhdfs. */ -struct hdfs_internal { - libhdfs_hdfsFS libhdfsRep; - libhdfspp_hdfsFS libhdfsppRep; -}; -typedef struct hdfs_internal* hdfsFS; - -struct hdfsFile_internal { - libhdfs_hdfsFile libhdfsRep; - libhdfspp_hdfsFile libhdfsppRep; -}; -typedef struct hdfsFile_internal* hdfsFile; - -struct hdfsBuilder { - struct hdfsBuilder * libhdfs_builder; - struct hdfsBuilder * libhdfspp_builder; -}; - -#define REPORT_FUNCTION_NOT_IMPLEMENTED \ - fprintf(stderr, "%s failed: function not implemented by " \ - "libhdfs++ test shim", __PRETTY_FUNCTION__); - -int hdfsFileIsOpenForWrite(hdfsFile file) { - return libhdfs_hdfsFileIsOpenForWrite(file->libhdfsRep); -} - -int hdfsFileGetReadStatistics(hdfsFile file, struct hdfsReadStatistics **stats) { - //We do not track which bytes were remote or local, so we assume all are local - int ret = libhdfspp_hdfsFileGetReadStatistics(file->libhdfsppRep, (struct libhdfspp_hdfsReadStatistics **)stats); - if(!ret) { - (*stats)->totalLocalBytesRead = (*stats)->totalBytesRead; - } - return ret; -} - -int64_t hdfsReadStatisticsGetRemoteBytesRead(const struct hdfsReadStatistics *stats) { - return libhdfspp_hdfsReadStatisticsGetRemoteBytesRead((struct libhdfspp_hdfsReadStatistics *)stats); -} - -int hdfsFileClearReadStatistics(hdfsFile file) { - return libhdfspp_hdfsFileClearReadStatistics(file->libhdfsppRep); -} - -void hdfsFileFreeReadStatistics(struct hdfsReadStatistics *stats) { - libhdfspp_hdfsFileFreeReadStatistics((struct libhdfspp_hdfsReadStatistics *)stats); -} - -hdfsFS hdfsConnectAsUser(const char* nn, tPort port, const char *user) { - hdfsFS ret = calloc(1, sizeof(struct hdfs_internal)); - ret->libhdfsRep = libhdfs_hdfsConnectAsUser(nn, port, user); - if (!ret->libhdfsRep) { - libhdfs_hdfsDisconnect(ret->libhdfsRep); - free(ret); - return NULL; - } - ret->libhdfsppRep = libhdfspp_hdfsConnectAsUser(nn, port, user); - if (!ret->libhdfsppRep) { - libhdfs_hdfsDisconnect(ret->libhdfsRep); - free(ret); - return NULL; - } - return ret; -} - -hdfsFS hdfsConnect(const char* nn, tPort port) { - hdfsFS ret = calloc(1, sizeof(struct hdfs_internal)); - ret->libhdfsRep = libhdfs_hdfsConnect(nn, port); - if (!ret->libhdfsRep) { - libhdfs_hdfsDisconnect(ret->libhdfsRep); - free(ret); - return NULL; - } - ret->libhdfsppRep = libhdfspp_hdfsConnect(nn, port); - if (!ret->libhdfsppRep) { - libhdfs_hdfsDisconnect(ret->libhdfsRep); - free(ret); - return NULL; - } - return ret; -} - -hdfsFS hdfsConnectAsUserNewInstance(const char* nn, tPort port, const char *user ) { - hdfsFS ret = calloc(1, sizeof(struct hdfs_internal)); - ret->libhdfsRep = libhdfs_hdfsConnectAsUserNewInstance(nn, port, user); - if (!ret->libhdfsRep) { - libhdfs_hdfsDisconnect(ret->libhdfsRep); - free(ret); - return NULL; - } - ret->libhdfsppRep = libhdfspp_hdfsConnectAsUserNewInstance(nn, port, user); - if (!ret->libhdfsppRep) { - libhdfs_hdfsDisconnect(ret->libhdfsRep); - free(ret); - return NULL; - } - return ret; -} - -hdfsFS hdfsConnectNewInstance(const char* nn, tPort port) { - hdfsFS ret = calloc(1, sizeof(struct hdfs_internal)); - ret->libhdfsRep = libhdfs_hdfsConnectNewInstance(nn, port); - if (!ret->libhdfsRep) { - libhdfs_hdfsDisconnect(ret->libhdfsRep); - free(ret); - return NULL; - } - ret->libhdfsppRep = libhdfspp_hdfsConnectNewInstance(nn, port); - if (!ret->libhdfsppRep) { - libhdfs_hdfsDisconnect(ret->libhdfsRep); - free(ret); - return NULL; - } - return ret; -} - -hdfsFS hdfsBuilderConnect(struct hdfsBuilder *bld) { - hdfsFS ret = calloc(1, sizeof(struct hdfs_internal)); - ret->libhdfsRep = libhdfs_hdfsBuilderConnect(bld->libhdfs_builder); - if (!ret->libhdfsRep) { - free(ret); - return NULL; - } - /* Destroys bld object. */ - ret->libhdfsppRep = libhdfspp_hdfsBuilderConnect(bld->libhdfspp_builder); - if (!ret->libhdfsppRep) { - libhdfs_hdfsDisconnect(ret->libhdfsRep); - free(ret); - return NULL; - } - return ret; -} - -struct hdfsBuilder *hdfsNewBuilder(void) { - struct hdfsBuilder * result = calloc(1, sizeof(struct hdfsBuilder)); - result -> libhdfs_builder = libhdfs_hdfsNewBuilder(); - result -> libhdfspp_builder = libhdfspp_hdfsNewBuilder(); - return result; -} - -void hdfsBuilderSetForceNewInstance(struct hdfsBuilder *bld) { - libhdfs_hdfsBuilderSetForceNewInstance(bld->libhdfs_builder); - libhdfspp_hdfsBuilderSetForceNewInstance(bld->libhdfspp_builder); -} - -void hdfsBuilderSetNameNode(struct hdfsBuilder *bld, const char *nn) { - libhdfs_hdfsBuilderSetNameNode(bld->libhdfs_builder, nn); - libhdfspp_hdfsBuilderSetNameNode(bld->libhdfspp_builder, nn); -} - -void hdfsBuilderSetNameNodePort(struct hdfsBuilder *bld, tPort port) { - libhdfs_hdfsBuilderSetNameNodePort(bld->libhdfs_builder, port); - libhdfspp_hdfsBuilderSetNameNodePort(bld->libhdfspp_builder, port); -} - -void hdfsBuilderSetUserName(struct hdfsBuilder *bld, const char *userName) { - libhdfs_hdfsBuilderSetUserName(bld->libhdfs_builder, userName); - libhdfspp_hdfsBuilderSetUserName(bld->libhdfspp_builder, userName); -} - -void hdfsBuilderSetKerbTicketCachePath(struct hdfsBuilder *bld, - const char *kerbTicketCachePath) { - REPORT_FUNCTION_NOT_IMPLEMENTED -} - -void hdfsFreeBuilder(struct hdfsBuilder *bld) { - libhdfs_hdfsFreeBuilder(bld->libhdfs_builder); - libhdfspp_hdfsFreeBuilder(bld->libhdfspp_builder); - free(bld); -} - -int hdfsBuilderConfSetStr(struct hdfsBuilder *bld, const char *key, - const char *val) { - int ret = libhdfs_hdfsBuilderConfSetStr(bld->libhdfs_builder, key, val); - if (ret) { - return ret; - } - ret = libhdfspp_hdfsBuilderConfSetStr(bld->libhdfspp_builder, key, val); - if (ret) { - return ret; - } - return 0; -} - -int hdfsConfGetStr(const char *key, char **val) { - return libhdfspp_hdfsConfGetStr(key, val); -} - -int hdfsConfGetInt(const char *key, int32_t *val) { - return libhdfspp_hdfsConfGetInt(key, val); -} - -void hdfsConfStrFree(char *val) { - libhdfspp_hdfsConfStrFree(val); -} - -int hdfsDisconnect(hdfsFS fs) { - int ret1 = libhdfs_hdfsDisconnect(fs->libhdfsRep); - int ret2 = libhdfspp_hdfsDisconnect(fs->libhdfsppRep); - free(fs); - if (ret1){ - return ret1; - } else if (ret2){ - return ret2; - } else { - return 0; - } -} - -hdfsFile hdfsOpenFile(hdfsFS fs, const char* path, int flags, - int bufferSize, short replication, tSize blocksize) { - hdfsFile ret = calloc(1, sizeof(struct hdfsFile_internal)); - /* Currently only open libhdf++ for reads. */ - ret->libhdfsppRep = 0; - if (flags == O_RDONLY) { - ret->libhdfsppRep = libhdfspp_hdfsOpenFile(fs->libhdfsppRep, path, flags, - bufferSize, replication, blocksize); - } - ret->libhdfsRep = libhdfs_hdfsOpenFile(fs->libhdfsRep, path, - flags, bufferSize, replication, blocksize); - if (!ret->libhdfsRep) { - free(ret); - ret = NULL; - } - return ret; -} - -int hdfsTruncateFile(hdfsFS fs, const char* path, tOffset newlength) { - return libhdfs_hdfsTruncateFile(fs->libhdfsRep, path, newlength); -} - -int hdfsUnbufferFile(hdfsFile file) { - return libhdfs_hdfsUnbufferFile(file->libhdfsRep); -} - -int hdfsCloseFile(hdfsFS fs, hdfsFile file) { - int ret; - if (file->libhdfsppRep) { - libhdfspp_hdfsCloseFile(fs->libhdfsppRep, file->libhdfsppRep); - } - ret = libhdfs_hdfsCloseFile(fs->libhdfsRep, file->libhdfsRep); - free(file); - return ret; -} - -int hdfsExists(hdfsFS fs, const char *path) { - return libhdfspp_hdfsExists(fs->libhdfsppRep, path); -} - -int hdfsSeek(hdfsFS fs, hdfsFile file, tOffset desiredPos) { - int ret1 = libhdfs_hdfsSeek(fs->libhdfsRep, file->libhdfsRep, desiredPos); - int ret2 = libhdfspp_hdfsSeek(fs->libhdfsppRep, file->libhdfsppRep, desiredPos); - if (ret1) { - return ret1; - } else if (ret2) { - return ret2; - } else { - return 0; - } -} - -tOffset hdfsTell(hdfsFS fs, hdfsFile file) { - tOffset ret1 = libhdfs_hdfsTell(fs->libhdfsRep, file->libhdfsRep); - tOffset ret2 = libhdfspp_hdfsTell(fs->libhdfsppRep, file->libhdfsppRep); - if (ret1 != ret2) { - errno = EIO; - return -1; - } else { - return ret1; - } -} - -tSize hdfsRead(hdfsFS fs, hdfsFile file, void* buffer, tSize length) { - // Read to update stats. - tSize nRead = libhdfs_hdfsRead(fs->libhdfsRep, file->libhdfsRep, buffer, length); - // Clear to avoid false positives. - if (nRead > 0) memset(buffer, 0, nRead); - return libhdfspp_hdfsRead(fs->libhdfsppRep, file->libhdfsppRep, buffer, length); -} - -tSize hdfsPread(hdfsFS fs, hdfsFile file, tOffset position, - void* buffer, tSize length) { - tSize ret = -1; - if (!fs->libhdfsppRep) { - fprintf(stderr, "hdfsPread failed: no libhdfs++ file system"); - } else if (!file->libhdfsppRep) { - fprintf(stderr, "hdfsPread failed: no libhdfs++ file"); - } else { - ret = libhdfspp_hdfsPread(fs->libhdfsppRep, file->libhdfsppRep, - position, buffer, length); - } - return ret; -} - -tSize hdfsWrite(hdfsFS fs, hdfsFile file, const void* buffer, - tSize length) { - return libhdfs_hdfsWrite(fs->libhdfsRep, file->libhdfsRep, buffer, length); -} - -int hdfsFlush(hdfsFS fs, hdfsFile file) { - return libhdfs_hdfsFlush(fs->libhdfsRep, file->libhdfsRep); -} - -int hdfsHFlush(hdfsFS fs, hdfsFile file) { - return libhdfs_hdfsHFlush(fs->libhdfsRep, file->libhdfsRep); -} - -int hdfsHSync(hdfsFS fs, hdfsFile file) { - return libhdfs_hdfsHSync(fs->libhdfsRep, file->libhdfsRep); -} - -int hdfsAvailable(hdfsFS fs, hdfsFile file) { - return libhdfspp_hdfsAvailable(fs->libhdfsppRep, file->libhdfsppRep); -} - -int hdfsCopy(hdfsFS srcFS, const char* src, hdfsFS dstFS, const char* dst) { - return libhdfs_hdfsCopy(srcFS->libhdfsRep, src, dstFS->libhdfsRep, dst); -} - -int hdfsMove(hdfsFS srcFS, const char* src, hdfsFS dstFS, const char* dst) { - return libhdfs_hdfsMove(srcFS->libhdfsRep, src, dstFS->libhdfsRep, dst); -} - -int hdfsDelete(hdfsFS fs, const char* path, int recursive) { - return libhdfspp_hdfsDelete(fs->libhdfsppRep, path, recursive); -} - -int hdfsRename(hdfsFS fs, const char* oldPath, const char* newPath) { - return libhdfspp_hdfsRename(fs->libhdfsppRep, oldPath, newPath); -} - -char* hdfsGetWorkingDirectory(hdfsFS fs, char *buffer, size_t bufferSize) { - return libhdfspp_hdfsGetWorkingDirectory(fs->libhdfsppRep, buffer, bufferSize); -} - -int hdfsSetWorkingDirectory(hdfsFS fs, const char* path) { - int ret1 = libhdfspp_hdfsSetWorkingDirectory(fs->libhdfsppRep, path); - int ret2 = libhdfs_hdfsSetWorkingDirectory(fs->libhdfsRep, path); - if (ret1) { - return ret1; - } else if (ret2) { - return ret2; - } else { - return 0; - } -} - -int hdfsCreateDirectory(hdfsFS fs, const char* path) { - return libhdfspp_hdfsCreateDirectory(fs->libhdfsppRep, path); -} - -int hdfsSetReplication(hdfsFS fs, const char* path, int16_t replication) { - return libhdfspp_hdfsSetReplication(fs->libhdfsppRep, path, replication); -} - -hdfsFileInfo *hdfsListDirectory(hdfsFS fs, const char* path, - int *numEntries) { - return (hdfsFileInfo *)libhdfspp_hdfsListDirectory(fs->libhdfsppRep, path, numEntries); -} - -hdfsFileInfo *hdfsGetPathInfo(hdfsFS fs, const char* path) { - return (hdfsFileInfo *)libhdfspp_hdfsGetPathInfo(fs->libhdfsppRep, path); -} - -void hdfsFreeFileInfo(hdfsFileInfo *hdfsFileInfo, int numEntries) { - return libhdfspp_hdfsFreeFileInfo - ((libhdfspp_hdfsFileInfo *) hdfsFileInfo, numEntries); -} - -int hdfsFileIsEncrypted(hdfsFileInfo *hdfsFileInfo) { - return libhdfs_hdfsFileIsEncrypted - ((libhdfs_hdfsFileInfo *) hdfsFileInfo); -} - -char*** hdfsGetHosts(hdfsFS fs, const char* path, - tOffset start, tOffset length) { - return libhdfspp_hdfsGetHosts(fs->libhdfsppRep, path, start, length); -} - -void hdfsFreeHosts(char ***blockHosts) { - return libhdfspp_hdfsFreeHosts(blockHosts); -} - -tOffset hdfsGetDefaultBlockSize(hdfsFS fs) { - return libhdfspp_hdfsGetDefaultBlockSize(fs->libhdfsppRep); -} - -tOffset hdfsGetDefaultBlockSizeAtPath(hdfsFS fs, const char *path) { - return libhdfspp_hdfsGetDefaultBlockSizeAtPath(fs->libhdfsppRep, path); -} - -tOffset hdfsGetCapacity(hdfsFS fs) { - return libhdfspp_hdfsGetCapacity(fs->libhdfsppRep); -} - -tOffset hdfsGetUsed(hdfsFS fs) { - return libhdfspp_hdfsGetUsed(fs->libhdfsppRep); -} - -int hdfsChown(hdfsFS fs, const char* path, const char *owner, - const char *group) { - return libhdfspp_hdfsChown(fs->libhdfsppRep, path, owner, group); -} - -int hdfsChmod(hdfsFS fs, const char* path, short mode) { - return libhdfspp_hdfsChmod(fs->libhdfsppRep, path, mode); -} - -int hdfsUtime(hdfsFS fs, const char* path, tTime mtime, tTime atime) { - return libhdfspp_hdfsUtime(fs->libhdfsppRep, path, mtime, atime); -} - -struct hadoopRzOptions *hadoopRzOptionsAlloc(void) { - return libhdfs_hadoopRzOptionsAlloc(); -} - -int hadoopRzOptionsSetSkipChecksum( - struct hadoopRzOptions *opts, int skip) { - return libhdfs_hadoopRzOptionsSetSkipChecksum(opts, skip); -} - -int hadoopRzOptionsSetByteBufferPool( - struct hadoopRzOptions *opts, const char *className) { - return libhdfs_hadoopRzOptionsSetByteBufferPool(opts, className); -} - -void hadoopRzOptionsFree(struct hadoopRzOptions *opts) { - libhdfs_hadoopRzOptionsFree(opts); -} - -struct hadoopRzBuffer* hadoopReadZero(hdfsFile file, - struct hadoopRzOptions *opts, int32_t maxLength) { - return libhdfs_hadoopReadZero(file->libhdfsRep, opts, maxLength); -} - -int32_t hadoopRzBufferLength(const struct hadoopRzBuffer *buffer) { - return libhdfs_hadoopRzBufferLength(buffer); -} - -const void *hadoopRzBufferGet(const struct hadoopRzBuffer *buffer) { - return libhdfs_hadoopRzBufferGet(buffer); -} - -void hadoopRzBufferFree(hdfsFile file, struct hadoopRzBuffer *buffer) { - return libhdfs_hadoopRzBufferFree(file->libhdfsRep, buffer); -} - -int hdfsGetHedgedReadMetrics(hdfsFS fs, struct hdfsHedgedReadMetrics **metrics) { - return libhdfs_hdfsGetHedgedReadMetrics(fs->libhdfsRep, (struct libhdfs_hdfsHedgedReadMetrics **) metrics); -} - -void hdfsFreeHedgedReadMetrics(struct hdfsHedgedReadMetrics *metrics) { - return libhdfs_hdfsFreeHedgedReadMetrics((struct libhdfs_hdfsHedgedReadMetrics *) metrics); -} - -/************* - * hdfs_ext functions - */ - -int hdfsGetLastError(char *buf, int len) { - return libhdfspp_hdfsGetLastError(buf, len); -} - -int hdfsCancel(hdfsFS fs, hdfsFile file) { - return libhdfspp_hdfsCancel(fs->libhdfsppRep, file->libhdfsppRep); -} - - -int hdfsGetBlockLocations(hdfsFS fs, const char *path, struct hdfsBlockLocations ** locations) { - return libhdfspp_hdfsGetBlockLocations(fs->libhdfsppRep, path, locations); -} - -int hdfsFreeBlockLocations(struct hdfsBlockLocations * locations) { - return libhdfspp_hdfsFreeBlockLocations(locations); -} - -hdfsFileInfo *hdfsFind(hdfsFS fs, const char* path, const char* name, uint32_t *numEntries) { - return (hdfsFileInfo *)libhdfspp_hdfsFind(fs->libhdfsppRep, path, name, numEntries); -} - -int hdfsCreateSnapshot(hdfsFS fs, const char* path, const char* name) { - return libhdfspp_hdfsCreateSnapshot(fs->libhdfsppRep, path, name); -} - -int hdfsDeleteSnapshot(hdfsFS fs, const char* path, const char* name) { - return libhdfspp_hdfsDeleteSnapshot(fs->libhdfsppRep, path, name); -} - -int hdfsRenameSnapshot(hdfsFS fs, const char* path, const char* old_name, const char* new_name) { - return libhdfspp_hdfsRenameSnapshot(fs->libhdfsppRep, path, old_name, new_name); -} - -int hdfsAllowSnapshot(hdfsFS fs, const char* path) { - return libhdfspp_hdfsAllowSnapshot(fs->libhdfsppRep, path); -} - -int hdfsDisallowSnapshot(hdfsFS fs, const char* path) { - return libhdfspp_hdfsDisallowSnapshot(fs->libhdfsppRep, path); -} http://git-wip-us.apache.org/repos/asf/hadoop/blob/7a542fb3/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/hdfspp_errors.cc ---------------------------------------------------------------------- diff --git a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/hdfspp_errors.cc b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/hdfspp_errors.cc deleted file mode 100644 index f49f5fa..0000000 --- a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/hdfspp_errors.cc +++ /dev/null @@ -1,116 +0,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. - */ - - -#include <hdfs/hdfs.h> -#include <hdfspp/hdfs_ext.h> - -#include <google/protobuf/io/coded_stream.h> -#include <gmock/gmock.h> - -#include <string.h> -#include <string> - -using ::testing::_; -using ::testing::InvokeArgument; -using ::testing::Return; - -/* Don't need a real minidfs cluster since this just passes invalid params. */ - -TEST(HdfsppErrors, NullFileSystem) { - - char buf[4096]; - - hdfsFS fs = nullptr; - hdfsFile fd = reinterpret_cast<hdfsFile>(1); - - tSize res = hdfsRead(fs, fd, buf, 4096); - ASSERT_EQ(res, -1); - - hdfsGetLastError(buf, 4096); - - ASSERT_EQ(std::string(buf), "Cannot perform FS operations with null FS handle."); -} - -TEST(HdfsppErrors, NullFileHandle) { - char buf[4096]; - - hdfsFS fs = reinterpret_cast<hdfsFS>(1); - hdfsFile fd = nullptr; - - tSize res = hdfsRead(fs, fd, buf, 4096); - ASSERT_EQ(res, -1); - - hdfsGetLastError(buf, 4096); - - ASSERT_EQ(std::string(buf), "Cannot perform FS operations with null File handle."); -} - -TEST(HdfsppErrors, ZeroLength) { - char buf[1]; - buf[0] = 0; - - hdfsFS fs = reinterpret_cast<hdfsFS>(1); - hdfsFile fd = nullptr; - - tSize res = hdfsRead(fs, fd, buf, 1); - ASSERT_EQ(res, -1); - - hdfsGetLastError(buf, 0); - - ASSERT_EQ(std::string(buf), ""); -} - -TEST(HdfsppErrors, NegativeLength) { - char buf[1]; - buf[0] = 0; - - hdfsFS fs = reinterpret_cast<hdfsFS>(1); - hdfsFile fd = nullptr; - - tSize res = hdfsRead(fs, fd, buf, 1); - ASSERT_EQ(res, -1); - - hdfsGetLastError(buf, -1); - - ASSERT_EQ(std::string(buf), ""); -} - -TEST(HdfsppErrors, MessageTruncation) { - char buf[4096]; - - hdfsFS fs = reinterpret_cast<hdfsFS>(1); - hdfsFile fd = nullptr; - - tSize res = hdfsRead(fs, fd, buf, 4096); - ASSERT_EQ(res, -1); - - hdfsGetLastError(buf, 10); - - ASSERT_EQ(std::string(buf), "Cannot pe"); -} - -int main(int argc, char *argv[]) { - // The following line must be executed to initialize Google Mock - // (and Google Test) before running the tests. - ::testing::InitGoogleMock(&argc, argv); - int exit_code = RUN_ALL_TESTS(); - google::protobuf::ShutdownProtobufLibrary(); - - return exit_code; -} http://git-wip-us.apache.org/repos/asf/hadoop/blob/7a542fb3/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/hdfspp_mini_dfs.h ---------------------------------------------------------------------- diff --git a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/hdfspp_mini_dfs.h b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/hdfspp_mini_dfs.h deleted file mode 100644 index aecced1..0000000 --- a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/hdfspp_mini_dfs.h +++ /dev/null @@ -1,194 +0,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. - */ - -#include "hdfs/hdfs.h" -#include "hdfspp/hdfspp.h" -#include <native_mini_dfs.h> - -#include <google/protobuf/io/coded_stream.h> -#include <gmock/gmock.h> - -#include <string> -#include <atomic> - -#define TO_STR_HELPER(X) #X -#define TO_STR(X) TO_STR_HELPER(X) - -#define TEST_BLOCK_SIZE 134217728 - -namespace hdfs { - - -static std::atomic<int> dirnum; -static std::atomic<int> filenum; - - -class FSHandle { -public: - FSHandle() : fs(nullptr) {} - FSHandle(FileSystem * fs_in) : fs(fs_in) {} - - - FileSystem * handle() { return fs.get(); } - operator FileSystem *() { return fs.get(); } -protected: - std::shared_ptr<FileSystem> fs; -}; - - -/** - * For tests going through the C API to libhdfs++ - */ - -class HdfsHandle { -public: - HdfsHandle() : fs(nullptr) { - } - - HdfsHandle(hdfsFS fs_in) : fs(fs_in) { - } - - ~HdfsHandle () { - if (fs) { - EXPECT_EQ(0, hdfsDisconnect(fs)); - } - } - - std::string newDir(const std::string & parent_dir = "/") { - int newDirNum = dirnum++; - - std::string path = parent_dir; - if (path.back() != '/') - path += "/"; - path += "dir" + std::to_string(newDirNum) + "/"; - - EXPECT_EQ(0, hdfsCreateDirectory(*this, path.c_str())); - return path; - } - - std::string newFile(const std::string & dir = "/", size_t size = 1024) { - int newFileNum = filenum++; - - std::string path = dir; - if (path.back() != '/') - path += "/"; - path += "file" + std::to_string(newFileNum); - - hdfsFile file = hdfsOpenFile(*this, path.c_str(), O_WRONLY, 0, 0, 0); - EXPECT_NE(nullptr, file); - void * buf = malloc(size); - bzero(buf, size); - EXPECT_EQ(1024, hdfsWrite(*this, file, buf, size)); - EXPECT_EQ(0, hdfsCloseFile(*this, file)); - free(buf); - - return path; - } - - std::string newFile(size_t size) { - return newFile("/", size); - } - - hdfsFS handle() { return fs; } - operator hdfsFS() { return fs; } -private: - hdfsFS fs; -}; - - -class MiniCluster { -public: - MiniCluster() : io_service(IoService::MakeShared()) { - struct NativeMiniDfsConf conf = { - 1, /* doFormat */ - 0, /* webhdfs */ - -1, /* webhdfs port */ - 1 /* shortcircuit */ - }; - clusterInfo = nmdCreate(&conf); - EXPECT_NE(nullptr, clusterInfo); - EXPECT_EQ(0, nmdWaitClusterUp(clusterInfo)); - - //TODO: Write some files for tests to read/check - } - - virtual ~MiniCluster() { - if (clusterInfo) { - EXPECT_EQ(0, nmdShutdown(clusterInfo)); - } - nmdFree(clusterInfo); - } - - // Connect via the C++ API - FSHandle connect(const std::string username) { - Options options; - - unsigned int worker_count = io_service->InitDefaultWorkers(); - EXPECT_NE(0, worker_count); - - FileSystem * fs = FileSystem::New(io_service, username, options); - EXPECT_NE(nullptr, fs); - FSHandle result(fs); - - tPort port = (tPort)nmdGetNameNodePort(clusterInfo); - EXPECT_NE(0, port); - Status status = fs->Connect("localhost", std::to_string(port)); - EXPECT_EQ(true, status.ok()); - return result; - } - - FSHandle connect() { - return connect(""); - } - - // Connect via the C API - HdfsHandle connect_c(const std::string & username) { - tPort port; - hdfsFS hdfs; - struct hdfsBuilder *bld; - - port = (tPort)nmdGetNameNodePort(clusterInfo); - bld = hdfsNewBuilder(); - EXPECT_NE(nullptr, bld); - hdfsBuilderSetForceNewInstance(bld); - hdfsBuilderSetNameNode(bld, "localhost"); - hdfsBuilderSetNameNodePort(bld, port); - hdfsBuilderConfSetStr(bld, "dfs.block.size", - TO_STR(TEST_BLOCK_SIZE)); - hdfsBuilderConfSetStr(bld, "dfs.blocksize", - TO_STR(TEST_BLOCK_SIZE)); - if (!username.empty()) { - hdfsBuilderSetUserName(bld, username.c_str()); - } - hdfs = hdfsBuilderConnect(bld); - EXPECT_NE(nullptr, hdfs); - - return HdfsHandle(hdfs); - } - - // Connect via the C API - HdfsHandle connect_c() { - return connect_c(""); - } - -protected: - struct NativeMiniDfsCluster* clusterInfo; - std::shared_ptr<IoService> io_service; -}; - -} // namespace http://git-wip-us.apache.org/repos/asf/hadoop/blob/7a542fb3/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/hdfspp_mini_dfs_smoke.cc ---------------------------------------------------------------------- diff --git a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/hdfspp_mini_dfs_smoke.cc b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/hdfspp_mini_dfs_smoke.cc deleted file mode 100644 index aaa2903..0000000 --- a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/hdfspp_mini_dfs_smoke.cc +++ /dev/null @@ -1,49 +0,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. - */ - -#include "hdfspp_mini_dfs.h" - -namespace hdfs { - -class HdfsMiniDfsSmokeTest: public ::testing::Test { -public: - MiniCluster cluster; -}; - -// Make sure we can set up a mini-cluster and connect to it -TEST_F(HdfsMiniDfsSmokeTest, SmokeTest) { - FSHandle handle = cluster.connect(); - EXPECT_NE(nullptr, handle.handle()); - - HdfsHandle connection = cluster.connect_c(); - EXPECT_NE(nullptr, connection.handle()); -} - - -} - - -int main(int argc, char *argv[]) { - // The following line must be executed to initialize Google Mock - // (and Google Test) before running the tests. - ::testing::InitGoogleMock(&argc, argv); - int exit_code = RUN_ALL_TESTS(); - google::protobuf::ShutdownProtobufLibrary(); - - return exit_code; -} http://git-wip-us.apache.org/repos/asf/hadoop/blob/7a542fb3/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfs_wrapper.c ---------------------------------------------------------------------- diff --git a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfs_wrapper.c b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfs_wrapper.c deleted file mode 100644 index 8a7124b..0000000 --- a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfs_wrapper.c +++ /dev/null @@ -1,22 +0,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. - */ - -/* Rename libhdfs structs and functions */ -#include "libhdfs_wrapper_defines.h" -#include "libhdfs/hdfs.c" -#include "libhdfs_wrapper_undefs.h" http://git-wip-us.apache.org/repos/asf/hadoop/blob/7a542fb3/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfs_wrapper.h ---------------------------------------------------------------------- diff --git a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfs_wrapper.h b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfs_wrapper.h deleted file mode 100644 index e8e716c..0000000 --- a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfs_wrapper.h +++ /dev/null @@ -1,28 +0,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. - */ - -/* "Original" symbols can be included elsewhere. */ -#undef LIBHDFS_HDFS_H - -/* Rename libhdfs structs and functions */ -#include "libhdfs_wrapper_defines.h" -#include "hdfs/hdfs.h" -#include "libhdfs_wrapper_undefs.h" - -/* "Original" symbols can be included elsewhere. */ -#undef LIBHDFS_HDFS_H http://git-wip-us.apache.org/repos/asf/hadoop/blob/7a542fb3/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfs_wrapper_defines.h ---------------------------------------------------------------------- diff --git a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfs_wrapper_defines.h b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfs_wrapper_defines.h deleted file mode 100644 index b907768..0000000 --- a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfs_wrapper_defines.h +++ /dev/null @@ -1,97 +0,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. - */ -#define hdfsFileIsOpenForRead libhdfs_hdfsFileIsOpenForRead -#define hdfsFileIsOpenForWrite libhdfs_hdfsFileIsOpenForWrite -#define hdfsFileGetReadStatistics libhdfs_hdfsFileGetReadStatistics -#define hdfsReadStatisticsGetRemoteBytesRead libhdfs_hdfsReadStatisticsGetRemoteBytesRead -#define hdfsFileClearReadStatistics libhdfs_hdfsFileClearReadStatistics -#define hdfsFileFreeReadStatistics libhdfs_hdfsFileFreeReadStatistics -#define hdfsConnectAsUser libhdfs_hdfsConnectAsUser -#define hdfsConnect libhdfs_hdfsConnect -#define hdfsConnectAsUserNewInstance libhdfs_hdfsConnectAsUserNewInstance -#define hdfsConnectNewInstance libhdfs_hdfsConnectNewInstance -#define hdfsBuilderConnect libhdfs_hdfsBuilderConnect -#define hdfsNewBuilder libhdfs_hdfsNewBuilder -#define hdfsBuilderSetForceNewInstance libhdfs_hdfsBuilderSetForceNewInstance -#define hdfsBuilderSetNameNode libhdfs_hdfsBuilderSetNameNode -#define hdfsBuilderSetNameNodePort libhdfs_hdfsBuilderSetNameNodePort -#define hdfsBuilderSetUserName libhdfs_hdfsBuilderSetUserName -#define hdfsBuilderSetKerbTicketCachePath libhdfs_hdfsBuilderSetKerbTicketCachePath -#define hdfsFreeBuilder libhdfs_hdfsFreeBuilder -#define hdfsBuilderConfSetStr libhdfs_hdfsBuilderConfSetStr -#define hdfsConfGetStr libhdfs_hdfsConfGetStr -#define hdfsConfGetInt libhdfs_hdfsConfGetInt -#define hdfsConfStrFree libhdfs_hdfsConfStrFree -#define hdfsDisconnect libhdfs_hdfsDisconnect -#define hdfsOpenFile libhdfs_hdfsOpenFile -#define hdfsTruncateFile libhdfs_hdfsTruncateFile -#define hdfsUnbufferFile libhdfs_hdfsUnbufferFile -#define hdfsCloseFile libhdfs_hdfsCloseFile -#define hdfsExists libhdfs_hdfsExists -#define hdfsSeek libhdfs_hdfsSeek -#define hdfsTell libhdfs_hdfsTell -#define hdfsRead libhdfs_hdfsRead -#define hdfsPread libhdfs_hdfsPread -#define hdfsWrite libhdfs_hdfsWrite -#define hdfsFlush libhdfs_hdfsFlush -#define hdfsHFlush libhdfs_hdfsHFlush -#define hdfsHSync libhdfs_hdfsHSync -#define hdfsAvailable libhdfs_hdfsAvailable -#define hdfsCopy libhdfs_hdfsCopy -#define hdfsMove libhdfs_hdfsMove -#define hdfsDelete libhdfs_hdfsDelete -#define hdfsRename libhdfs_hdfsRename -#define hdfsGetWorkingDirectory libhdfs_hdfsGetWorkingDirectory -#define hdfsSetWorkingDirectory libhdfs_hdfsSetWorkingDirectory -#define hdfsCreateDirectory libhdfs_hdfsCreateDirectory -#define hdfsSetReplication libhdfs_hdfsSetReplication -#define hdfsListDirectory libhdfs_hdfsListDirectory -#define hdfsGetPathInfo libhdfs_hdfsGetPathInfo -#define hdfsFreeFileInfo libhdfs_hdfsFreeFileInfo -#define hdfsFileIsEncrypted libhdfs_hdfsFileIsEncrypted -#define hdfsGetHosts libhdfs_hdfsGetHosts -#define hdfsFreeHosts libhdfs_hdfsFreeHosts -#define hdfsGetDefaultBlockSize libhdfs_hdfsGetDefaultBlockSize -#define hdfsGetDefaultBlockSizeAtPath libhdfs_hdfsGetDefaultBlockSizeAtPath -#define hdfsGetCapacity libhdfs_hdfsGetCapacity -#define hdfsGetUsed libhdfs_hdfsGetUsed -#define hdfsChown libhdfs_hdfsChown -#define hdfsChmod libhdfs_hdfsChmod -#define hdfsUtime libhdfs_hdfsUtime -#define hadoopRzOptionsAlloc libhdfs_hadoopRzOptionsAlloc -#define hadoopRzOptionsSetSkipChecksum libhdfs_hadoopRzOptionsSetSkipChecksum -#define hadoopRzOptionsSetByteBufferPool libhdfs_hadoopRzOptionsSetByteBufferPool -#define hadoopRzOptionsFree libhdfs_hadoopRzOptionsFree -#define hadoopReadZero libhdfs_hadoopReadZero -#define hadoopRzBufferLength libhdfs_hadoopRzBufferLength -#define hadoopRzBufferGet libhdfs_hadoopRzBufferGet -#define hadoopRzBufferFree libhdfs_hadoopRzBufferFree -#define hdfs_internal libhdfs_hdfs_internal -#define hdfsFS libhdfs_hdfsFS -#define hdfsFile_internal libhdfs_hdfsFile_internal -#define hdfsFile libhdfs_hdfsFile -#define tObjectKind libhdfs_tObjectKind -#define kObjectKindFile libhdfs_kObjectKindFile -#define kObjectKindDirectory libhdfs_kObjectKindDirectory -#define hdfsReadStatistics libhdfs_hdfsReadStatistics -#define hdfsFileInfo libhdfs_hdfsFileInfo -#define hdfsHedgedReadMetrics libhdfs_hdfsHedgedReadMetrics -#define hdfsGetHedgedReadMetrics libhdfs_hdfsGetHedgedReadMetrics -#define hdfsFreeHedgedReadMetrics libhdfs_hdfsFreeHedgedReadMetrics -#define hdfsStreamBuilderAlloc libhdfs_hdfsStreamBuilderAlloc -#define hdfsStreamBuilderBuild libhdfs_hdfsStreamBuilderBuild http://git-wip-us.apache.org/repos/asf/hadoop/blob/7a542fb3/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfs_wrapper_undefs.h ---------------------------------------------------------------------- diff --git a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfs_wrapper_undefs.h b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfs_wrapper_undefs.h deleted file mode 100644 index fce0e82..0000000 --- a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfs_wrapper_undefs.h +++ /dev/null @@ -1,107 +0,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. - */ -#undef hdfsFileIsOpenForRead -#undef hdfsFileIsOpenForWrite -#undef hdfsFileGetReadStatistics -#undef hdfsReadStatisticsGetRemoteBytesRead -#undef hdfsFileClearReadStatistics -#undef hdfsFileFreeReadStatistics -#undef hdfsConnectAsUser -#undef hdfsConnect -#undef hdfsConnectAsUserNewInstance -#undef hdfsConnectNewInstance -#undef hdfsBuilderConnect -#undef hdfsNewBuilder -#undef hdfsBuilderSetForceNewInstance -#undef hdfsBuilderSetNameNode -#undef hdfsBuilderSetNameNodePort -#undef hdfsBuilderSetUserName -#undef hdfsBuilderSetKerbTicketCachePath -#undef hdfsFreeBuilder -#undef hdfsBuilderConfSetStr -#undef hdfsConfGetStr -#undef hdfsConfGetInt -#undef hdfsConfStrFree -#undef hdfsDisconnect -#undef hdfsOpenFile -#undef hdfsTruncateFile -#undef hdfsUnbufferFile -#undef hdfsCloseFile -#undef hdfsExists -#undef hdfsSeek -#undef hdfsTell -#undef hdfsRead -#undef hdfsPread -#undef hdfsWrite -#undef hdfsFlush -#undef hdfsHFlush -#undef hdfsHSync -#undef hdfsAvailable -#undef hdfsCopy -#undef hdfsMove -#undef hdfsDelete -#undef hdfsRename -#undef hdfsGetWorkingDirectory -#undef hdfsSetWorkingDirectory -#undef hdfsCreateDirectory -#undef hdfsSetReplication -#undef hdfsListDirectory -#undef hdfsGetPathInfo -#undef hdfsFreeFileInfo -#undef hdfsFileIsEncrypted -#undef hdfsGetHosts -#undef hdfsFreeHosts -#undef hdfsGetDefaultBlockSize -#undef hdfsGetDefaultBlockSizeAtPath -#undef hdfsGetCapacity -#undef hdfsGetUsed -#undef hdfsChown -#undef hdfsChmod -#undef hdfsUtime -#undef hadoopRzOptionsAlloc -#undef hadoopRzOptionsSetSkipChecksum -#undef hadoopRzOptionsSetByteBufferPool -#undef hadoopRzOptionsFree -#undef hadoopReadZero -#undef hadoopRzBufferLength -#undef hadoopRzBufferGet -#undef hadoopRzBufferFree -#undef hdfs_internal -#undef hdfsFS -#undef hdfsFile_internal -#undef hdfsFile -#undef tObjectKind -#undef kObjectKindFile -#undef kObjectKindDirectory -#undef hdfsReadStatistics -#undef hdfsFileInfo -#undef hdfsGetLastError -#undef hdfsCancel -#undef hdfsGetBlockLocations -#undef hdfsFreeBlockLocations -#undef hdfsFind -#undef hdfsCreateSnapshot -#undef hdfsDeleteSnapshot -#undef hdfsRenameSnapshot -#undef hdfsAllowSnapshot -#undef hdfsDisallowSnapshot -#undef hdfsHedgedReadMetrics -#undef hdfsGetHedgedReadMetrics -#undef hdfsFreeHedgedReadMetrics -#undef hdfsStreamBuilderAlloc -#undef hdfsStreamBuilderBuild http://git-wip-us.apache.org/repos/asf/hadoop/blob/7a542fb3/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfspp_wrapper.cc ---------------------------------------------------------------------- diff --git a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfspp_wrapper.cc b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfspp_wrapper.cc deleted file mode 100644 index 913bd6c..0000000 --- a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfspp_wrapper.cc +++ /dev/null @@ -1,22 +0,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. - */ - -/* Rename libhdfspp structs and functions */ -#include "libhdfspp_wrapper_defines.h" -#include "bindings/c/hdfs.cc" -#include "libhdfs_wrapper_undefs.h" http://git-wip-us.apache.org/repos/asf/hadoop/blob/7a542fb3/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfspp_wrapper.h ---------------------------------------------------------------------- diff --git a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfspp_wrapper.h b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfspp_wrapper.h deleted file mode 100644 index 8cd78d2..0000000 --- a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfspp_wrapper.h +++ /dev/null @@ -1,29 +0,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. - */ - -/* "Original" symbols can be included elsewhere. */ -#undef LIBHDFS_HDFS_H - -/* Rename libhdfspp structs and functions */ -#include "libhdfspp_wrapper_defines.h" -#include "hdfs/hdfs.h" -#include "hdfspp/hdfs_ext.h" -#include "libhdfs_wrapper_undefs.h" - -/* "Original" symbols can be included elsewhere. */ -#undef LIBHDFS_HDFS_H http://git-wip-us.apache.org/repos/asf/hadoop/blob/7a542fb3/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfspp_wrapper_defines.h ---------------------------------------------------------------------- diff --git a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfspp_wrapper_defines.h b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfspp_wrapper_defines.h deleted file mode 100644 index d0411c2..0000000 --- a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfspp_wrapper_defines.h +++ /dev/null @@ -1,107 +0,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. - */ -#define hdfsFileIsOpenForRead libhdfspp_hdfsFileIsOpenForRead -#define hdfsFileIsOpenForWrite libhdfspp_hdfsFileIsOpenForWrite -#define hdfsFileGetReadStatistics libhdfspp_hdfsFileGetReadStatistics -#define hdfsReadStatisticsGetRemoteBytesRead libhdfspp_hdfsReadStatisticsGetRemoteBytesRead -#define hdfsFileClearReadStatistics libhdfspp_hdfsFileClearReadStatistics -#define hdfsFileFreeReadStatistics libhdfspp_hdfsFileFreeReadStatistics -#define hdfsConnectAsUser libhdfspp_hdfsConnectAsUser -#define hdfsConnect libhdfspp_hdfsConnect -#define hdfsConnectAsUserNewInstance libhdfspp_hdfsConnectAsUserNewInstance -#define hdfsConnectNewInstance libhdfspp_hdfsConnectNewInstance -#define hdfsBuilderConnect libhdfspp_hdfsBuilderConnect -#define hdfsNewBuilder libhdfspp_hdfsNewBuilder -#define hdfsBuilderSetForceNewInstance libhdfspp_hdfsBuilderSetForceNewInstance -#define hdfsBuilderSetNameNode libhdfspp_hdfsBuilderSetNameNode -#define hdfsBuilderSetNameNodePort libhdfspp_hdfsBuilderSetNameNodePort -#define hdfsBuilderSetUserName libhdfspp_hdfsBuilderSetUserName -#define hdfsBuilderSetKerbTicketCachePath libhdfspp_hdfsBuilderSetKerbTicketCachePath -#define hdfsFreeBuilder libhdfspp_hdfsFreeBuilder -#define hdfsBuilderConfSetStr libhdfspp_hdfsBuilderConfSetStr -#define hdfsConfGetStr libhdfspp_hdfsConfGetStr -#define hdfsConfGetInt libhdfspp_hdfsConfGetInt -#define hdfsConfStrFree libhdfspp_hdfsConfStrFree -#define hdfsDisconnect libhdfspp_hdfsDisconnect -#define hdfsOpenFile libhdfspp_hdfsOpenFile -#define hdfsTruncateFile libhdfspp_hdfsTruncateFile -#define hdfsUnbufferFile libhdfspp_hdfsUnbufferFile -#define hdfsCloseFile libhdfspp_hdfsCloseFile -#define hdfsExists libhdfspp_hdfsExists -#define hdfsSeek libhdfspp_hdfsSeek -#define hdfsTell libhdfspp_hdfsTell -#define hdfsRead libhdfspp_hdfsRead -#define hdfsPread libhdfspp_hdfsPread -#define hdfsWrite libhdfspp_hdfsWrite -#define hdfsFlush libhdfspp_hdfsFlush -#define hdfsHFlush libhdfspp_hdfsHFlush -#define hdfsHSync libhdfspp_hdfsHSync -#define hdfsAvailable libhdfspp_hdfsAvailable -#define hdfsCopy libhdfspp_hdfsCopy -#define hdfsMove libhdfspp_hdfsMove -#define hdfsDelete libhdfspp_hdfsDelete -#define hdfsRename libhdfspp_hdfsRename -#define hdfsGetWorkingDirectory libhdfspp_hdfsGetWorkingDirectory -#define hdfsSetWorkingDirectory libhdfspp_hdfsSetWorkingDirectory -#define hdfsCreateDirectory libhdfspp_hdfsCreateDirectory -#define hdfsSetReplication libhdfspp_hdfsSetReplication -#define hdfsListDirectory libhdfspp_hdfsListDirectory -#define hdfsGetPathInfo libhdfspp_hdfsGetPathInfo -#define hdfsFreeFileInfo libhdfspp_hdfsFreeFileInfo -#define hdfsFileIsEncrypted libhdfspp_hdfsFileIsEncrypted -#define hdfsGetHosts libhdfspp_hdfsGetHosts -#define hdfsFreeHosts libhdfspp_hdfsFreeHosts -#define hdfsGetDefaultBlockSize libhdfspp_hdfsGetDefaultBlockSize -#define hdfsGetDefaultBlockSizeAtPath libhdfspp_hdfsGetDefaultBlockSizeAtPath -#define hdfsGetCapacity libhdfspp_hdfsGetCapacity -#define hdfsGetUsed libhdfspp_hdfsGetUsed -#define hdfsChown libhdfspp_hdfsChown -#define hdfsChmod libhdfspp_hdfsChmod -#define hdfsUtime libhdfspp_hdfsUtime -#define hadoopRzOptionsAlloc libhdfspp_hadoopRzOptionsAlloc -#define hadoopRzOptionsSetSkipChecksum libhdfspp_hadoopRzOptionsSetSkipChecksum -#define hadoopRzOptionsSetByteBufferPool libhdfspp_hadoopRzOptionsSetByteBufferPool -#define hadoopRzOptionsFree libhdfspp_hadoopRzOptionsFree -#define hadoopReadZero libhdfspp_hadoopReadZero -#define hadoopRzBufferLength libhdfspp_hadoopRzBufferLength -#define hadoopRzBufferGet libhdfspp_hadoopRzBufferGet -#define hadoopRzBufferFree libhdfspp_hadoopRzBufferFree -#define hdfs_internal libhdfspp_hdfs_internal -#define hdfsFS libhdfspp_hdfsFS -#define hdfsFile_internal libhdfspp_hdfsFile_internal -#define hdfsFile libhdfspp_hdfsFile -#define tObjectKind libhdfspp_tObjectKind -#define kObjectKindFile libhdfspp_kObjectKindFile -#define kObjectKindDirectory libhdfspp_kObjectKindDirectory -#define hdfsReadStatistics libhdfspp_hdfsReadStatistics -#define hdfsFileInfo libhdfspp_hdfsFileInfo -#define hdfsGetLastError libhdfspp_hdfsGetLastError -#define hdfsCancel libhdfspp_hdfsCancel -#define hdfsGetBlockLocations libhdfspp_hdfsGetBlockLocations -#define hdfsFreeBlockLocations libhdfspp_hdfsFreeBlockLocations -#define hdfsFind libhdfspp_hdfsFind -#define hdfsCreateSnapshot libhdfspp_hdfsCreateSnapshot -#define hdfsDeleteSnapshot libhdfspp_hdfsDeleteSnapshot -#define hdfsRenameSnapshot libhdfspp_hdfsRenameSnapshot -#define hdfsAllowSnapshot libhdfspp_hdfsAllowSnapshot -#define hdfsDisallowSnapshot libhdfspp_hdfsDisallowSnapshot -#define hdfsHedgedReadMetrics libhdfspp_hdfsHedgedReadMetrics -#define hdfsGetHedgedReadMetrics libhdfspp_hdfsGetHedgedReadMetrics -#define hdfsFreeHedgedReadMetrics libhdfspp_hdfsFreeHedgedReadMetrics -#define hdfsStreamBuilderAlloc libhdfspp_hdfsStreamBuilderAlloc -#define hdfsStreamBuilderBuild libhdfspp_hdfsStreamBuilderBuild --------------------------------------------------------------------- To unsubscribe, e-mail: common-commits-unsubscr...@hadoop.apache.org For additional commands, e-mail: common-commits-h...@hadoop.apache.org
