From a38703fdfc3484f8a0fc0580b5ca0e9d1ccdd2d3 Mon Sep 17 00:00:00 2001 From: James Date: Tue, 24 Nov 2015 17:56:26 -0500 Subject: [PATCH] HDFS-9359. Test libhdfs++ with existing libhdfs tests. Contributed by Stephen Walkauskas. --- .../native/libhdfspp/tests/CMakeLists.txt | 22 + .../main/native/libhdfspp/tests/hdfs_shim.c | 381 ++++++++++++++++++ .../native/libhdfspp/tests/libhdfs_wrapper.c | 22 + .../native/libhdfspp/tests/libhdfs_wrapper.h | 28 ++ .../libhdfspp/tests/libhdfs_wrapper_defines.h | 92 +++++ .../libhdfspp/tests/libhdfs_wrapper_undefs.h | 92 +++++ .../libhdfspp/tests/libhdfspp_wrapper.cc | 22 + .../libhdfspp/tests/libhdfspp_wrapper.h | 28 ++ .../tests/libhdfspp_wrapper_defines.h | 92 +++++ 9 files changed, 779 insertions(+) create mode 100644 hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/hdfs_shim.c create mode 100644 hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfs_wrapper.c create mode 100644 hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfs_wrapper.h create mode 100644 hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfs_wrapper_defines.h create mode 100644 hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfs_wrapper_undefs.h create mode 100644 hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfspp_wrapper.cc create mode 100644 hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfspp_wrapper.h create mode 100644 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/CMakeLists.txt b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/CMakeLists.txt index 51b6bfeee15..abd3858af9b 100644 --- a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/CMakeLists.txt +++ b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/CMakeLists.txt @@ -16,6 +16,24 @@ # limitations under the License. # +# Delegate some functionality to libhdfs, until libhdfspp is complete. +set (LIBHDFS_SRC_DIR ../../libhdfs) +set (LIBHDFS_TESTS_DIR ../../libhdfs-tests) +set (LIBHDFSPP_SRC_DIR ..) +set (LIBHDFSPP_LIB_DIR ${LIBHDFSPP_SRC_DIR}/lib) +set (LIBHDFSPP_BINDING_C ${LIBHDFSPP_LIB_DIR}/bindings/c) +include_directories( + ${GENERATED_JAVAH} + ${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_BINARY_DIR} + ${JNI_INCLUDE_DIRS} + ${LIBHDFS_SRC_DIR}/include + ${LIBHDFS_SRC_DIR}/.. + ${LIBHDFS_SRC_DIR} + ${OS_DIR} +) +add_library(hdfspp_test_shim_static STATIC hdfs_shim.c libhdfs_wrapper.c libhdfspp_wrapper.cc ${LIBHDFSPP_BINDING_C}/hdfs_cpp.cc) + add_library(test_common OBJECT mock_connection.cc) set(PROTOBUF_IMPORT_DIRS ${PROTO_HADOOP_TEST_DIR}) @@ -49,3 +67,7 @@ add_test(bad_datanode bad_datanode_test) add_executable(node_exclusion_test node_exclusion_test.cc) target_link_libraries(node_exclusion_test fs gmock_main common ${PROTOBUF_LIBRARIES} ${OPENSSL_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}) add_test(node_exclusion node_exclusion_test) + +build_libhdfs_test(libhdfs_threaded hdfspp_test_shim_static expect.c test_libhdfs_threaded.c ${OS_DIR}/thread.c) +link_libhdfs_test(libhdfs_threaded hdfspp_test_shim_static fs reader rpc proto common ${PROTOBUF_LIBRARIES} ${OPENSSL_LIBRARIES} native_mini_dfs ${JAVA_JVM_LIBRARY}) +add_libhdfs_test(libhdfs_threaded hdfspp_test_shim_static) 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 new file mode 100644 index 00000000000..3954440f13b --- /dev/null +++ b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/hdfs_shim.c @@ -0,0 +1,381 @@ +/** + * 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 +#include +#include + +/* Cheat for now and use the same hdfsBuilder as libhdfs */ +/* (libhdfspp doesn't have an hdfsBuilder yet). */ +struct hdfsBuilder { + int forceNewInstance; + const char *nn; + tPort port; + const char *kerbTicketCachePath; + const char *userName; + struct hdfsBuilderConfOpt *opts; +}; + +/* 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; + +#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) { + return libhdfs_hdfsFileGetReadStatistics + (file->libhdfsRep, (struct libhdfs_hdfsReadStatistics **)stats); +} + +int64_t hdfsReadStatisticsGetRemoteBytesRead( + const struct hdfsReadStatistics *stats) { + return libhdfs_hdfsReadStatisticsGetRemoteBytesRead + ((struct libhdfs_hdfsReadStatistics *)stats); +} + +int hdfsFileClearReadStatistics(hdfsFile file) { + return libhdfs_hdfsFileClearReadStatistics(file->libhdfsRep); +} + +void hdfsFileFreeReadStatistics(struct hdfsReadStatistics *stats) { + libhdfs_hdfsFileFreeReadStatistics( + (struct libhdfs_hdfsReadStatistics *)stats); +} + +hdfsFS hdfsConnectAsUser(const char* nn, tPort port, const char *user) { + REPORT_FUNCTION_NOT_IMPLEMENTED + return NULL; +} + +hdfsFS hdfsConnect(const char* nn, tPort port) { + REPORT_FUNCTION_NOT_IMPLEMENTED + return NULL; +} + +hdfsFS hdfsConnectAsUserNewInstance(const char* nn, tPort port, const char *user ) { + REPORT_FUNCTION_NOT_IMPLEMENTED + return NULL; +} + +hdfsFS hdfsConnectNewInstance(const char* nn, tPort port) { + REPORT_FUNCTION_NOT_IMPLEMENTED + return NULL; +} + +hdfsFS hdfsBuilderConnect(struct hdfsBuilder *bld) { + hdfsFS ret = calloc(1, sizeof(struct hdfs_internal)); + ret->libhdfsppRep = libhdfspp_hdfsConnect(bld->nn, bld->port); + if (!ret->libhdfsppRep) { + free(ret); + ret = NULL; + } else { + /* Destroys bld object. */ + ret->libhdfsRep = libhdfs_hdfsBuilderConnect(bld); + if (!ret->libhdfsRep) { + libhdfspp_hdfsDisconnect(ret->libhdfsppRep); + free(ret); + ret = NULL; + } + } + return ret; +} + +struct hdfsBuilder *hdfsNewBuilder(void) { + return libhdfs_hdfsNewBuilder(); +} + +void hdfsBuilderSetForceNewInstance(struct hdfsBuilder *bld) { + libhdfs_hdfsBuilderSetForceNewInstance(bld); +} + +void hdfsBuilderSetNameNode(struct hdfsBuilder *bld, const char *nn) { + libhdfs_hdfsBuilderSetNameNode(bld, nn); +} + +void hdfsBuilderSetNameNodePort(struct hdfsBuilder *bld, tPort port) { + libhdfs_hdfsBuilderSetNameNodePort(bld, port); +} + +void hdfsBuilderSetUserName(struct hdfsBuilder *bld, const char *userName) { + libhdfs_hdfsBuilderSetUserName(bld, userName); +} + +void hdfsBuilderSetKerbTicketCachePath(struct hdfsBuilder *bld, + const char *kerbTicketCachePath) { + libhdfs_hdfsBuilderSetKerbTicketCachePath(bld, kerbTicketCachePath); +} + +void hdfsFreeBuilder(struct hdfsBuilder *bld) { + libhdfs_hdfsFreeBuilder(bld); +} + +int hdfsBuilderConfSetStr(struct hdfsBuilder *bld, const char *key, + const char *val) { + return libhdfs_hdfsBuilderConfSetStr(bld, key, val); +} + +int hdfsConfGetStr(const char *key, char **val) { + return libhdfs_hdfsConfGetStr(key, val); +} + +int hdfsConfGetInt(const char *key, int32_t *val) { + return libhdfs_hdfsConfGetInt(key, val); +} + +void hdfsConfStrFree(char *val) { + libhdfs_hdfsConfStrFree(val); +} + +int hdfsDisconnect(hdfsFS fs) { + int ret; + libhdfspp_hdfsDisconnect(fs->libhdfsppRep); + ret = libhdfs_hdfsDisconnect(fs->libhdfsRep); + free(fs); + return ret; +} + +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 libhdfs_hdfsExists(fs->libhdfsRep, path); +} + +int hdfsSeek(hdfsFS fs, hdfsFile file, tOffset desiredPos) { + return libhdfs_hdfsSeek(fs->libhdfsRep, file->libhdfsRep, desiredPos); +} + +tOffset hdfsTell(hdfsFS fs, hdfsFile file) { + return libhdfs_hdfsTell(fs->libhdfsRep, file->libhdfsRep); +} + +tSize hdfsRead(hdfsFS fs, hdfsFile file, void* buffer, tSize length) { + return libhdfs_hdfsRead(fs->libhdfsRep, file->libhdfsRep, 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 libhdfs_hdfsAvailable(fs->libhdfsRep, file->libhdfsRep); +} + +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 libhdfs_hdfsDelete(fs->libhdfsRep, path, recursive); +} + +int hdfsRename(hdfsFS fs, const char* oldPath, const char* newPath) { + return libhdfs_hdfsRename(fs->libhdfsRep, oldPath, newPath); +} + +char* hdfsGetWorkingDirectory(hdfsFS fs, char *buffer, size_t bufferSize) { + return libhdfs_hdfsGetWorkingDirectory(fs->libhdfsRep, buffer, bufferSize); +} + +int hdfsSetWorkingDirectory(hdfsFS fs, const char* path) { + return libhdfs_hdfsSetWorkingDirectory(fs->libhdfsRep, path); +} + +int hdfsCreateDirectory(hdfsFS fs, const char* path) { + return libhdfs_hdfsCreateDirectory(fs->libhdfsRep, path); +} + +int hdfsSetReplication(hdfsFS fs, const char* path, int16_t replication) { + return libhdfs_hdfsSetReplication(fs->libhdfsRep, path, replication); +} + +hdfsFileInfo *hdfsListDirectory(hdfsFS fs, const char* path, + int *numEntries) { + return (hdfsFileInfo *)libhdfs_hdfsListDirectory(fs->libhdfsRep, path, numEntries); +} + +hdfsFileInfo *hdfsGetPathInfo(hdfsFS fs, const char* path) { + return (hdfsFileInfo *)libhdfs_hdfsGetPathInfo(fs->libhdfsRep, path); +} + +void hdfsFreeFileInfo(hdfsFileInfo *hdfsFileInfo, int numEntries) { + return libhdfs_hdfsFreeFileInfo + ((libhdfs_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 libhdfs_hdfsGetHosts(fs->libhdfsRep, path, start, length); +} + +void hdfsFreeHosts(char ***blockHosts) { + return libhdfs_hdfsFreeHosts(blockHosts); +} + +tOffset hdfsGetDefaultBlockSize(hdfsFS fs) { + return libhdfs_hdfsGetDefaultBlockSize(fs->libhdfsRep); +} + +tOffset hdfsGetDefaultBlockSizeAtPath(hdfsFS fs, const char *path) { + return libhdfs_hdfsGetDefaultBlockSizeAtPath(fs->libhdfsRep, path); +} + +tOffset hdfsGetCapacity(hdfsFS fs) { + return libhdfs_hdfsGetCapacity(fs->libhdfsRep); +} + +tOffset hdfsGetUsed(hdfsFS fs) { + return libhdfs_hdfsGetUsed(fs->libhdfsRep); +} + +int hdfsChown(hdfsFS fs, const char* path, const char *owner, + const char *group) { + return libhdfs_hdfsChown(fs->libhdfsRep, path, owner, group); +} + +int hdfsChmod(hdfsFS fs, const char* path, short mode) { + return libhdfs_hdfsChmod(fs->libhdfsRep, path, mode); +} + +int hdfsUtime(hdfsFS fs, const char* path, tTime mtime, tTime atime) { + return libhdfs_hdfsUtime(fs->libhdfsRep, 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); +} 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 new file mode 100644 index 00000000000..8a7124b5ee2 --- /dev/null +++ b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfs_wrapper.c @@ -0,0 +1,22 @@ +/** + * 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" 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 new file mode 100644 index 00000000000..e8e716cdb0e --- /dev/null +++ b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfs_wrapper.h @@ -0,0 +1,28 @@ +/** + * 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 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 new file mode 100644 index 00000000000..fcf31859614 --- /dev/null +++ b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfs_wrapper_defines.h @@ -0,0 +1,92 @@ +/** + * 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 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 new file mode 100644 index 00000000000..787a11c8f72 --- /dev/null +++ b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfs_wrapper_undefs.h @@ -0,0 +1,92 @@ +/** + * 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 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 new file mode 100644 index 00000000000..913bd6ca482 --- /dev/null +++ b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfspp_wrapper.cc @@ -0,0 +1,22 @@ +/** + * 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" 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 new file mode 100644 index 00000000000..802c5abc469 --- /dev/null +++ b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfspp_wrapper.h @@ -0,0 +1,28 @@ +/** + * 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 "libhdfs_wrapper_undefs.h" + +/* "Original" symbols can be included elsewhere. */ +#undef LIBHDFS_HDFS_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 new file mode 100644 index 00000000000..3ca0e69cd7f --- /dev/null +++ b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/libhdfspp_wrapper_defines.h @@ -0,0 +1,92 @@ +/** + * 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