You are viewing a plain text version of this content. The canonical link for it is here.
Posted to common-commits@hadoop.apache.org by ae...@apache.org on 2018/03/23 00:56:59 UTC
[39/51] [abbrv] [partial] hadoop git commit: Revert "Merge branch
'trunk' into HDFS-7240"
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-unsubscribe@hadoop.apache.org
For additional commands, e-mail: common-commits-help@hadoop.apache.org