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 jh...@apache.org on 2018/03/22 21:21:40 UTC
[37/52] [abbrv] hadoop git commit: HDFS-11544: libhdfs++: Improve C
API error reporting. Contributed by James Clampffer.
HDFS-11544: libhdfs++: Improve C API error reporting. Contributed by James Clampffer.
Project: http://git-wip-us.apache.org/repos/asf/hadoop/repo
Commit: http://git-wip-us.apache.org/repos/asf/hadoop/commit/fdb88eb5
Tree: http://git-wip-us.apache.org/repos/asf/hadoop/tree/fdb88eb5
Diff: http://git-wip-us.apache.org/repos/asf/hadoop/diff/fdb88eb5
Branch: refs/heads/HDFS-8707
Commit: fdb88eb57e18273d31681d31202320da0b0ca61e
Parents: 3e53da2
Author: James <jh...@apache.org>
Authored: Tue Mar 21 12:37:13 2017 -0400
Committer: James Clampffer <ja...@hp.com>
Committed: Thu Mar 22 17:19:47 2018 -0400
----------------------------------------------------------------------
.../native/libhdfspp/lib/bindings/c/hdfs.cc | 800 ++++++++++---------
1 file changed, 402 insertions(+), 398 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/hadoop/blob/fdb88eb5/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/lib/bindings/c/hdfs.cc
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/lib/bindings/c/hdfs.cc b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/lib/bindings/c/hdfs.cc
index 0608244..2856b0d 100644
--- a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/lib/bindings/c/hdfs.cc
+++ b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/lib/bindings/c/hdfs.cc
@@ -41,6 +41,23 @@ using namespace std::placeholders;
static constexpr tPort kDefaultPort = 8020;
+// Functions exposed through the C API and extended C API get tagged with no-op
+// defines. This is to make it really clear what's being exposed in a way that
+// won't blend into the comments. Can also be used to add attributes or disable
+// the extensions e.g. "#define HDFS_EXT_API static"
+// API declared in hdfs.h shared with libhdfs
+#define HDFS_API
+// API extension functions specific to libhdfs++ declared in hdfs_ext.h
+#define HDFS_EXT_API
+
+// Common catch-all case to get exception and return the appropriate error code
+#define CATCH_AND_REPORT catch (const std::exception & e) { return ReportException(e); } \
+ catch (...) { return ReportCaughtNonException(); }
+
+
+
+
+
/* Separate the handles used by the C api from the C++ API*/
struct hdfs_internal {
hdfs_internal(FileSystem *p) : filesystem_(p), working_directory_("/") {}
@@ -79,9 +96,14 @@ struct hdfsFile_internal {
thread_local std::string errstr;
/* Fetch last error that happened in this thread */
+HDFS_EXT_API
int hdfsGetLastError(char *buf, int len) {
//No error message
if(errstr.empty()){
+ if(len > 0) {
+ // Null terminator if there is space
+ *buf = 0;
+ }
return -1;
}
@@ -104,6 +126,17 @@ int hdfsGetLastError(char *buf, int len) {
return 0;
}
+/* Clear out last error. This shouldn't need to be public if functions do it themselves */
+static void resetErrorForApiCall(const char *location = nullptr) {
+ // POSIX spec says caller should be responsible for resetting errno.
+ // Clearing it here just in case.
+ errno = 0;
+ if(location)
+ errstr = std::string(location) + " has not set an error message";
+ else
+ errstr.clear();
+}
+
/* Event callbacks for next open calls */
thread_local std::experimental::optional<fs_event_callback> fsEventCallback;
thread_local std::experimental::optional<file_event_callback> fileEventCallback;
@@ -255,7 +288,9 @@ optional<std::string> getAbsolutePath(hdfsFS fs, const char* path) {
* C API implementations
**/
+HDFS_API
int hdfsFileIsOpenForRead(hdfsFile file) {
+ resetErrorForApiCall("hdfsFileIsOpenForRead");
/* files can only be open for reads at the moment, do a quick check */
if (!CheckHandle(file)){
return 0;
@@ -263,7 +298,9 @@ int hdfsFileIsOpenForRead(hdfsFile file) {
return 1; // Update implementation when we get file writing
}
+HDFS_API
int hdfsFileIsOpenForWrite(hdfsFile file) {
+ resetErrorForApiCall("hdfsFileIsOpenForWrite");
/* files can only be open for reads at the moment, so return false */
CheckHandle(file);
return -1; // Update implementation when we get file writing
@@ -276,11 +313,7 @@ int hdfsConfGetLong(const char *key, int64_t *val)
errno = 0;
hdfsBuilder builder;
return hdfsBuilderConfGetLong(&builder, key, val);
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
- }
+ } CATCH_AND_REPORT
}
hdfsFS doHdfsConnect(optional<std::string> nn, optional<tPort> port, optional<std::string> user, const Options & options) {
@@ -332,11 +365,12 @@ hdfsFS doHdfsConnect(optional<std::string> nn, optional<tPort> port, optional<st
}
}
+HDFS_EXT_API
hdfsFS hdfsAllocateFileSystem(struct hdfsBuilder *bld) {
+ resetErrorForApiCall("hdfsAllocateFileSystem");
// Same idea as the first half of doHdfsConnect, but return the wrapped FS before
// connecting.
try {
- errno = 0;
std::shared_ptr<IoService> io_service = IoService::MakeShared();
int io_thread_count = bld->config.GetOptions().io_threads_;
@@ -367,7 +401,9 @@ hdfsFS hdfsAllocateFileSystem(struct hdfsBuilder *bld) {
return nullptr;
}
+HDFS_EXT_API
int hdfsConnectAllocated(hdfsFS fs, struct hdfsBuilder *bld) {
+ resetErrorForApiCall("hdfsConnectAllocated");
if(!CheckSystem(fs)) {
return ENODEV;
}
@@ -420,25 +456,35 @@ int hdfsConnectAllocated(hdfsFS fs, struct hdfsBuilder *bld) {
return 0;
}
+HDFS_API
hdfsFS hdfsConnect(const char *nn, tPort port) {
- return hdfsConnectAsUser(nn, port, "");
+ resetErrorForApiCall("hdfsConnect");
+ return doHdfsConnect(std::string(nn), port, std::string(""), Options());
}
+HDFS_API
hdfsFS hdfsConnectAsUser(const char* nn, tPort port, const char *user) {
+ resetErrorForApiCall("hdfsConnectAsUser");
return doHdfsConnect(std::string(nn), port, std::string(user), Options());
}
+HDFS_API
hdfsFS hdfsConnectAsUserNewInstance(const char* nn, tPort port, const char *user ) {
+ resetErrorForApiCall("hdfsConnectAsUserNewInstance");
//libhdfspp always returns a new instance
return doHdfsConnect(std::string(nn), port, std::string(user), Options());
}
+HDFS_API
hdfsFS hdfsConnectNewInstance(const char* nn, tPort port) {
+ resetErrorForApiCall("hdfsConnectNewInstance");
//libhdfspp always returns a new instance
- return hdfsConnectAsUser(nn, port, "");
+ return doHdfsConnect(std::string(nn), port, std::string(""), Options());
}
+HDFS_EXT_API
int hdfsCancelPendingConnection(hdfsFS fs) {
+ resetErrorForApiCall("hdfsCancelPendingConnection");
// todo: stick an enum in hdfs_internal to check the connect state
if(!CheckSystem(fs)) {
return ENODEV;
@@ -458,10 +504,11 @@ int hdfsCancelPendingConnection(hdfsFS fs) {
}
}
+HDFS_API
int hdfsDisconnect(hdfsFS fs) {
+ resetErrorForApiCall("hdfsDisconnect");
try
{
- errno = 0;
if (!fs) {
ReportError(ENODEV, "Cannot disconnect null FS handle.");
return -1;
@@ -469,18 +516,15 @@ int hdfsDisconnect(hdfsFS fs) {
delete fs;
return 0;
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
- }
+ } CATCH_AND_REPORT
}
+HDFS_API
hdfsFile hdfsOpenFile(hdfsFS fs, const char *path, int flags, int bufferSize,
short replication, tSize blocksize) {
+ resetErrorForApiCall("hdfsOpenFile");
try
{
- errno = 0;
(void)flags;
(void)bufferSize;
(void)replication;
@@ -512,26 +556,24 @@ hdfsFile hdfsOpenFile(hdfsFS fs, const char *path, int flags, int bufferSize,
}
}
+HDFS_API
int hdfsCloseFile(hdfsFS fs, hdfsFile file) {
+ resetErrorForApiCall("hdfsCloseFile");
try
{
- errno = 0;
if (!CheckSystemAndHandle(fs, file)) {
return -1;
}
delete file;
return 0;
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
- }
+ } CATCH_AND_REPORT
}
+HDFS_API
char* hdfsGetWorkingDirectory(hdfsFS fs, char *buffer, size_t bufferSize) {
+ resetErrorForApiCall("hdfsGetWorkingDirectory");
try
{
- errno = 0;
if (!CheckSystem(fs)) {
return nullptr;
}
@@ -556,10 +598,11 @@ char* hdfsGetWorkingDirectory(hdfsFS fs, char *buffer, size_t bufferSize) {
}
}
+HDFS_API
int hdfsSetWorkingDirectory(hdfsFS fs, const char* path) {
+ resetErrorForApiCall("hdfsSetWorkingDirectory");
try
{
- errno = 0;
if (!CheckSystem(fs)) {
return -1;
}
@@ -575,25 +618,23 @@ int hdfsSetWorkingDirectory(hdfsFS fs, const char* path) {
}
fs->set_working_directory(withSlash);
return 0;
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
- }
+ } CATCH_AND_REPORT
}
+HDFS_API
int hdfsAvailable(hdfsFS fs, hdfsFile file) {
+ resetErrorForApiCall("hdfsAvailable");
//Since we do not have read ahead implemented, return 0 if fs and file are good;
- errno = 0;
if (!CheckSystemAndHandle(fs, file)) {
return -1;
}
return 0;
}
+HDFS_API
tOffset hdfsGetDefaultBlockSize(hdfsFS fs) {
+ resetErrorForApiCall("hdfsGetDefaultBlockSize");
try {
- errno = 0;
return fs->get_impl()->get_options().block_size;
} catch (const std::exception & e) {
ReportException(e);
@@ -604,9 +645,10 @@ tOffset hdfsGetDefaultBlockSize(hdfsFS fs) {
}
}
+HDFS_API
tOffset hdfsGetDefaultBlockSizeAtPath(hdfsFS fs, const char *path) {
+ resetErrorForApiCall("hdfsGetDefaultBlockSizeAtPath");
try {
- errno = 0;
if (!CheckSystem(fs)) {
return -1;
}
@@ -633,58 +675,53 @@ tOffset hdfsGetDefaultBlockSizeAtPath(hdfsFS fs, const char *path) {
}
}
+HDFS_API
int hdfsSetReplication(hdfsFS fs, const char* path, int16_t replication) {
- try {
- errno = 0;
- if (!CheckSystem(fs)) {
- return -1;
- }
- const optional<std::string> abs_path = getAbsolutePath(fs, path);
- if(!abs_path) {
- return -1;
- }
- if(replication < 1){
- return Error(Status::InvalidArgument("SetReplication: argument 'replication' cannot be less than 1"));
- }
- Status stat;
- stat = fs->get_impl()->SetReplication(*abs_path, replication);
- if (!stat.ok()) {
- return Error(stat);
- }
- return 0;
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
+ resetErrorForApiCall("hdfsSetReplication");
+ try {
+ if (!CheckSystem(fs)) {
+ return -1;
+ }
+ const optional<std::string> abs_path = getAbsolutePath(fs, path);
+ if(!abs_path) {
+ return -1;
+ }
+ if(replication < 1){
+ return Error(Status::InvalidArgument("SetReplication: argument 'replication' cannot be less than 1"));
+ }
+ Status stat;
+ stat = fs->get_impl()->SetReplication(*abs_path, replication);
+ if (!stat.ok()) {
+ return Error(stat);
}
+ return 0;
+ } CATCH_AND_REPORT
}
+HDFS_API
int hdfsUtime(hdfsFS fs, const char* path, tTime mtime, tTime atime) {
- try {
- errno = 0;
- if (!CheckSystem(fs)) {
- return -1;
- }
- const optional<std::string> abs_path = getAbsolutePath(fs, path);
- if(!abs_path) {
- return -1;
- }
- Status stat;
- stat = fs->get_impl()->SetTimes(*abs_path, mtime, atime);
- if (!stat.ok()) {
- return Error(stat);
- }
- return 0;
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
+ resetErrorForApiCall("hdfsUtime");
+ try {
+ if (!CheckSystem(fs)) {
+ return -1;
}
+ const optional<std::string> abs_path = getAbsolutePath(fs, path);
+ if(!abs_path) {
+ return -1;
+ }
+ Status stat;
+ stat = fs->get_impl()->SetTimes(*abs_path, mtime, atime);
+ if (!stat.ok()) {
+ return Error(stat);
+ }
+ return 0;
+ } CATCH_AND_REPORT
}
+HDFS_API
tOffset hdfsGetCapacity(hdfsFS fs) {
+ resetErrorForApiCall("hdfsGetCapacity");
try {
- errno = 0;
if (!CheckSystem(fs)) {
return -1;
}
@@ -705,9 +742,10 @@ tOffset hdfsGetCapacity(hdfsFS fs) {
}
}
+HDFS_API
tOffset hdfsGetUsed(hdfsFS fs) {
+ resetErrorForApiCall("hdfsGetUsed");
try {
- errno = 0;
if (!CheckSystem(fs)) {
return -1;
}
@@ -777,9 +815,10 @@ void StatInfoToHdfsFileInfo(hdfsFileInfo * file_info,
file_info->mLastAccess = stat_info.access_time;
}
+HDFS_API
int hdfsExists(hdfsFS fs, const char *path) {
+ resetErrorForApiCall("hdfsExists");
try {
- errno = 0;
if (!CheckSystem(fs)) {
return -1;
}
@@ -793,16 +832,13 @@ int hdfsExists(hdfsFS fs, const char *path) {
return Error(stat);
}
return 0;
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
- }
+ } CATCH_AND_REPORT
}
+HDFS_API
hdfsFileInfo *hdfsGetPathInfo(hdfsFS fs, const char* path) {
+ resetErrorForApiCall("hdfsGetPathInfo");
try {
- errno = 0;
if (!CheckSystem(fs)) {
return nullptr;
}
@@ -828,61 +864,64 @@ hdfsFileInfo *hdfsGetPathInfo(hdfsFS fs, const char* path) {
}
}
+HDFS_API
hdfsFileInfo *hdfsListDirectory(hdfsFS fs, const char* path, int *numEntries) {
+ resetErrorForApiCall("hdfsListDirectory");
try {
- errno = 0;
- if (!CheckSystem(fs)) {
- *numEntries = 0;
- return nullptr;
- }
- const optional<std::string> abs_path = getAbsolutePath(fs, path);
- if(!abs_path) {
- return nullptr;
- }
- std::vector<StatInfo> stat_infos;
- Status stat = fs->get_impl()->GetListing(*abs_path, &stat_infos);
- if (!stat.ok()) {
- Error(stat);
- *numEntries = 0;
- return nullptr;
- }
- if(stat_infos.empty()){
- *numEntries = 0;
- return nullptr;
- }
- *numEntries = stat_infos.size();
- hdfsFileInfo *file_infos = new hdfsFileInfo[stat_infos.size()];
- for(std::vector<StatInfo>::size_type i = 0; i < stat_infos.size(); i++) {
- StatInfoToHdfsFileInfo(&file_infos[i], stat_infos.at(i));
- }
-
- return file_infos;
- } catch (const std::exception & e) {
- ReportException(e);
+ if (!CheckSystem(fs)) {
+ *numEntries = 0;
+ return nullptr;
+ }
+ const optional<std::string> abs_path = getAbsolutePath(fs, path);
+ if(!abs_path) {
+ return nullptr;
+ }
+ std::vector<StatInfo> stat_infos;
+ Status stat = fs->get_impl()->GetListing(*abs_path, &stat_infos);
+ if (!stat.ok()) {
+ Error(stat);
*numEntries = 0;
return nullptr;
- } catch (...) {
- ReportCaughtNonException();
+ }
+ if(stat_infos.empty()){
*numEntries = 0;
return nullptr;
}
+ *numEntries = stat_infos.size();
+ hdfsFileInfo *file_infos = new hdfsFileInfo[stat_infos.size()];
+ for(std::vector<StatInfo>::size_type i = 0; i < stat_infos.size(); i++) {
+ StatInfoToHdfsFileInfo(&file_infos[i], stat_infos.at(i));
+ }
+
+ return file_infos;
+ } catch (const std::exception & e) {
+ ReportException(e);
+ *numEntries = 0;
+ return nullptr;
+ } catch (...) {
+ ReportCaughtNonException();
+ *numEntries = 0;
+ return nullptr;
+ }
}
+HDFS_API
void hdfsFreeFileInfo(hdfsFileInfo *hdfsFileInfo, int numEntries)
{
- errno = 0;
- int i;
- for (i = 0; i < numEntries; ++i) {
- delete[] hdfsFileInfo[i].mName;
- delete[] hdfsFileInfo[i].mOwner;
- delete[] hdfsFileInfo[i].mGroup;
- }
- delete[] hdfsFileInfo;
+ resetErrorForApiCall("hdfsFreeFileInfo");
+ int i;
+ for (i = 0; i < numEntries; ++i) {
+ delete[] hdfsFileInfo[i].mName;
+ delete[] hdfsFileInfo[i].mOwner;
+ delete[] hdfsFileInfo[i].mGroup;
+ }
+ delete[] hdfsFileInfo;
}
+HDFS_API
int hdfsCreateDirectory(hdfsFS fs, const char* path) {
+ resetErrorForApiCall("hdfsCreateDirectory");
try {
- errno = 0;
if (!CheckSystem(fs)) {
return -1;
}
@@ -891,45 +930,39 @@ int hdfsCreateDirectory(hdfsFS fs, const char* path) {
return -1;
}
Status stat;
- //Use default permissions and set true for creating all non-existant parent directories
+ //Use default permissions and set true for creating all non-existent parent directories
stat = fs->get_impl()->Mkdirs(*abs_path, FileSystem::GetDefaultPermissionMask(), true);
if (!stat.ok()) {
return Error(stat);
}
return 0;
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
- }
+ } CATCH_AND_REPORT
}
+HDFS_API
int hdfsDelete(hdfsFS fs, const char* path, int recursive) {
+ resetErrorForApiCall("hdfsDelete");
try {
- errno = 0;
- if (!CheckSystem(fs)) {
- return -1;
- }
- const optional<std::string> abs_path = getAbsolutePath(fs, path);
- if(!abs_path) {
- return -1;
- }
- Status stat;
- stat = fs->get_impl()->Delete(*abs_path, recursive);
- if (!stat.ok()) {
- return Error(stat);
- }
- return 0;
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
+ if (!CheckSystem(fs)) {
+ return -1;
+ }
+ const optional<std::string> abs_path = getAbsolutePath(fs, path);
+ if(!abs_path) {
+ return -1;
+ }
+ Status stat;
+ stat = fs->get_impl()->Delete(*abs_path, recursive);
+ if (!stat.ok()) {
+ return Error(stat);
}
+ return 0;
+ } CATCH_AND_REPORT
}
+HDFS_API
int hdfsRename(hdfsFS fs, const char* oldPath, const char* newPath) {
+ resetErrorForApiCall("hdfsRename");
try {
- errno = 0;
if (!CheckSystem(fs)) {
return -1;
}
@@ -944,106 +977,99 @@ int hdfsRename(hdfsFS fs, const char* oldPath, const char* newPath) {
return Error(stat);
}
return 0;
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
- }
+ } CATCH_AND_REPORT
}
+HDFS_API
int hdfsChmod(hdfsFS fs, const char* path, short mode){
+ resetErrorForApiCall("hdfsChmod");
try {
- errno = 0;
- if (!CheckSystem(fs)) {
- return -1;
- }
- const optional<std::string> abs_path = getAbsolutePath(fs, path);
- if(!abs_path) {
- return -1;
- }
- Status stat = FileSystem::CheckValidPermissionMask(mode);
- if (!stat.ok()) {
- return Error(stat);
- }
- stat = fs->get_impl()->SetPermission(*abs_path, mode);
- if (!stat.ok()) {
- return Error(stat);
- }
- return 0;
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
+ if (!CheckSystem(fs)) {
+ return -1;
+ }
+ const optional<std::string> abs_path = getAbsolutePath(fs, path);
+ if(!abs_path) {
+ return -1;
+ }
+ Status stat = FileSystem::CheckValidPermissionMask(mode);
+ if (!stat.ok()) {
+ return Error(stat);
+ }
+ stat = fs->get_impl()->SetPermission(*abs_path, mode);
+ if (!stat.ok()) {
+ return Error(stat);
}
+ return 0;
+ } CATCH_AND_REPORT
}
+HDFS_API
int hdfsChown(hdfsFS fs, const char* path, const char *owner, const char *group){
+ resetErrorForApiCall("hdfsChown");
try {
- errno = 0;
- if (!CheckSystem(fs)) {
- return -1;
- }
- const optional<std::string> abs_path = getAbsolutePath(fs, path);
- if(!abs_path) {
- return -1;
- }
- std::string own = (owner) ? owner : "";
- std::string grp = (group) ? group : "";
+ if (!CheckSystem(fs)) {
+ return -1;
+ }
+ const optional<std::string> abs_path = getAbsolutePath(fs, path);
+ if(!abs_path) {
+ return -1;
+ }
+ std::string own = (owner) ? owner : "";
+ std::string grp = (group) ? group : "";
- Status stat;
- stat = fs->get_impl()->SetOwner(*abs_path, own, grp);
- if (!stat.ok()) {
- return Error(stat);
- }
- return 0;
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
+ Status stat;
+ stat = fs->get_impl()->SetOwner(*abs_path, own, grp);
+ if (!stat.ok()) {
+ return Error(stat);
}
+ return 0;
+ } CATCH_AND_REPORT
}
-hdfsFileInfo * hdfsFind(hdfsFS fs, const char* path, const char* name, uint32_t * numEntries){
+HDFS_EXT_API
+hdfsFileInfo * hdfsFind(hdfsFS fs, const char* path, const char* name, uint32_t * numEntries)
+{
+ resetErrorForApiCall("hdfsFind");
try {
- errno = 0;
- if (!CheckSystem(fs)) {
- *numEntries = 0;
- return nullptr;
- }
-
- std::vector<StatInfo> stat_infos;
- Status stat = fs->get_impl()->Find(path, name, hdfs::FileSystem::GetDefaultFindMaxDepth(), &stat_infos);
- if (!stat.ok()) {
- Error(stat);
- *numEntries = 0;
- return nullptr;
- }
- //Existing API expects nullptr if size is 0
- if(stat_infos.empty()){
- *numEntries = 0;
- return nullptr;
- }
- *numEntries = stat_infos.size();
- hdfsFileInfo *file_infos = new hdfsFileInfo[stat_infos.size()];
- for(std::vector<StatInfo>::size_type i = 0; i < stat_infos.size(); i++) {
- StatInfoToHdfsFileInfo(&file_infos[i], stat_infos.at(i));
- }
+ if (!CheckSystem(fs)) {
+ *numEntries = 0;
+ return nullptr;
+ }
- return file_infos;
- } catch (const std::exception & e) {
- ReportException(e);
+ std::vector<StatInfo> stat_infos;
+ Status stat = fs->get_impl()->Find(path, name, hdfs::FileSystem::GetDefaultFindMaxDepth(), &stat_infos);
+ if (!stat.ok()) {
+ Error(stat);
*numEntries = 0;
return nullptr;
- } catch (...) {
- ReportCaughtNonException();
+ }
+ //Existing API expects nullptr if size is 0
+ if(stat_infos.empty()){
*numEntries = 0;
return nullptr;
}
+ *numEntries = stat_infos.size();
+ hdfsFileInfo *file_infos = new hdfsFileInfo[stat_infos.size()];
+ for(std::vector<StatInfo>::size_type i = 0; i < stat_infos.size(); i++) {
+ StatInfoToHdfsFileInfo(&file_infos[i], stat_infos.at(i));
+ }
+
+ return file_infos;
+ } catch (const std::exception & e) {
+ ReportException(e);
+ *numEntries = 0;
+ return nullptr;
+ } catch (...) {
+ ReportCaughtNonException();
+ *numEntries = 0;
+ return nullptr;
+ }
}
+HDFS_EXT_API
int hdfsCreateSnapshot(hdfsFS fs, const char* path, const char* name) {
+ resetErrorForApiCall("hdfsCreateSnapshot");
try {
- errno = 0;
if (!CheckSystem(fs)) {
return -1;
}
@@ -1061,16 +1087,13 @@ int hdfsCreateSnapshot(hdfsFS fs, const char* path, const char* name) {
return Error(stat);
}
return 0;
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
- }
+ } CATCH_AND_REPORT
}
+HDFS_EXT_API
int hdfsDeleteSnapshot(hdfsFS fs, const char* path, const char* name) {
+ resetErrorForApiCall("hdfsDeleteSnapshot");
try {
- errno = 0;
if (!CheckSystem(fs)) {
return -1;
}
@@ -1087,16 +1110,13 @@ int hdfsDeleteSnapshot(hdfsFS fs, const char* path, const char* name) {
return Error(stat);
}
return 0;
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
- }
+ } CATCH_AND_REPORT
}
+HDFS_EXT_API
int hdfsAllowSnapshot(hdfsFS fs, const char* path) {
+ resetErrorForApiCall("hdfsAllowSnapshot");
try {
- errno = 0;
if (!CheckSystem(fs)) {
return -1;
}
@@ -1110,16 +1130,13 @@ int hdfsAllowSnapshot(hdfsFS fs, const char* path) {
return Error(stat);
}
return 0;
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
- }
+ } CATCH_AND_REPORT
}
+HDFS_EXT_API
int hdfsDisallowSnapshot(hdfsFS fs, const char* path) {
+ resetErrorForApiCall("hdfsDisallowSnapshot");
try {
- errno = 0;
if (!CheckSystem(fs)) {
return -1;
}
@@ -1133,18 +1150,15 @@ int hdfsDisallowSnapshot(hdfsFS fs, const char* path) {
return Error(stat);
}
return 0;
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
- }
+ } CATCH_AND_REPORT
}
+HDFS_API
tSize hdfsPread(hdfsFS fs, hdfsFile file, tOffset position, void *buffer,
tSize length) {
+ resetErrorForApiCall("hdfsPread");
try
{
- errno = 0;
if (!CheckSystemAndHandle(fs, file)) {
return -1;
}
@@ -1155,17 +1169,14 @@ tSize hdfsPread(hdfsFS fs, hdfsFile file, tOffset position, void *buffer,
return Error(stat);
}
return (tSize)len;
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
- }
+ } CATCH_AND_REPORT
}
+HDFS_API
tSize hdfsRead(hdfsFS fs, hdfsFile file, void *buffer, tSize length) {
+ resetErrorForApiCall("hdfsRead");
try
{
- errno = 0;
if (!CheckSystemAndHandle(fs, file)) {
return -1;
}
@@ -1177,67 +1188,63 @@ tSize hdfsRead(hdfsFS fs, hdfsFile file, void *buffer, tSize length) {
}
return (tSize)len;
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
- }
+ } CATCH_AND_REPORT
}
+HDFS_API
int hdfsUnbufferFile(hdfsFile file) {
+ resetErrorForApiCall("hdfsUnbufferFile");
//Currently we are not doing any buffering
CheckHandle(file);
return -1;
}
+HDFS_API
int hdfsFileGetReadStatistics(hdfsFile file, struct hdfsReadStatistics **stats) {
+ resetErrorForApiCall("hdfsFileGetReadStatistics");
try
- {
- errno = 0;
- if (!CheckHandle(file)) {
- return -1;
- }
- *stats = new hdfsReadStatistics;
- memset(*stats, 0, sizeof(hdfsReadStatistics));
- (*stats)->totalBytesRead = file->get_impl()->get_bytes_read();
- return 0;
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
+ {
+ if (!CheckHandle(file)) {
+ return -1;
}
+ *stats = new hdfsReadStatistics;
+ memset(*stats, 0, sizeof(hdfsReadStatistics));
+ (*stats)->totalBytesRead = file->get_impl()->get_bytes_read();
+ return 0;
+ } CATCH_AND_REPORT
}
+HDFS_API
int hdfsFileClearReadStatistics(hdfsFile file) {
+ resetErrorForApiCall("hdfsFileClearReadStatistics");
try
- {
- errno = 0;
- if (!CheckHandle(file)) {
- return -1;
- }
- file->get_impl()->clear_bytes_read();
- return 0;
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
+ {
+ if (!CheckHandle(file)) {
+ return -1;
}
+ file->get_impl()->clear_bytes_read();
+ return 0;
+ } CATCH_AND_REPORT
}
+HDFS_API
int64_t hdfsReadStatisticsGetRemoteBytesRead(const struct hdfsReadStatistics *stats) {
- return stats->totalBytesRead - stats->totalLocalBytesRead;
+ resetErrorForApiCall("hdfsReadStatisticsGetRemoteBytesRead");
+ return stats->totalBytesRead - stats->totalLocalBytesRead;
}
+HDFS_API
void hdfsFileFreeReadStatistics(struct hdfsReadStatistics *stats) {
- errno = 0;
- delete stats;
+ resetErrorForApiCall("hdfsFileFreeReadStatistics");
+ delete stats;
}
/* 0 on success, -1 on error*/
+HDFS_API
int hdfsSeek(hdfsFS fs, hdfsFile file, tOffset desiredPos) {
+ resetErrorForApiCall("hdfsSeek");
try
{
- errno = 0;
if (!CheckSystemAndHandle(fs, file)) {
return -1;
}
@@ -1249,17 +1256,14 @@ int hdfsSeek(hdfsFS fs, hdfsFile file, tOffset desiredPos) {
}
return 0;
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
- }
+ } CATCH_AND_REPORT
}
+HDFS_API
tOffset hdfsTell(hdfsFS fs, hdfsFile file) {
+ resetErrorForApiCall("hdfsTell");
try
{
- errno = 0;
if (!CheckSystemAndHandle(fs, file)) {
return -1;
}
@@ -1271,36 +1275,30 @@ tOffset hdfsTell(hdfsFS fs, hdfsFile file) {
}
return offset;
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
- }
+ } CATCH_AND_REPORT
}
/* extended API */
+HDFS_EXT_API
int hdfsCancel(hdfsFS fs, hdfsFile file) {
+ resetErrorForApiCall("hdfsCancel");
try
{
- errno = 0;
if (!CheckSystemAndHandle(fs, file)) {
return -1;
}
static_cast<FileHandleImpl*>(file->get_impl())->CancelOperations();
return 0;
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
- }
+ } CATCH_AND_REPORT
}
+HDFS_EXT_API
int hdfsGetBlockLocations(hdfsFS fs, const char *path, struct hdfsBlockLocations ** locations_out)
{
+ resetErrorForApiCall("hdfsGetBlockLocations");
try
{
- errno = 0;
if (!CheckSystem(fs)) {
return -1;
}
@@ -1364,15 +1362,12 @@ int hdfsGetBlockLocations(hdfsFS fs, const char *path, struct hdfsBlockLocations
}
return 0;
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
- }
+ } CATCH_AND_REPORT
}
+HDFS_EXT_API
int hdfsFreeBlockLocations(struct hdfsBlockLocations * blockLocations) {
- errno = 0;
+ resetErrorForApiCall("hdfsFreeBlockLocations");
if (blockLocations == nullptr)
return 0;
@@ -1391,48 +1386,50 @@ int hdfsFreeBlockLocations(struct hdfsBlockLocations * blockLocations) {
return 0;
}
+HDFS_API
char*** hdfsGetHosts(hdfsFS fs, const char* path, tOffset start, tOffset length) {
+ resetErrorForApiCall("hdfsGetHosts");
try
- {
- errno = 0;
- if (!CheckSystem(fs)) {
- return nullptr;
- }
- const optional<std::string> abs_path = getAbsolutePath(fs, path);
- if(!abs_path) {
- return nullptr;
- }
- std::shared_ptr<FileBlockLocation> ppLocations;
- Status stat = fs->get_impl()->GetBlockLocations(*abs_path, start, length, &ppLocations);
- if (!stat.ok()) {
- Error(stat);
- return nullptr;
- }
- const std::vector<BlockLocation> & ppBlockLocations = ppLocations->getBlockLocations();
- char ***hosts = new char**[ppBlockLocations.size() + 1];
- for (size_t i=0; i < ppBlockLocations.size(); i++) {
- const std::vector<DNInfo> & ppDNInfos = ppBlockLocations[i].getDataNodes();
- hosts[i] = new char*[ppDNInfos.size() + 1];
- for (size_t j=0; j < ppDNInfos.size(); j++) {
- auto ppDNInfo = ppDNInfos[j];
- hosts[i][j] = new char[ppDNInfo.getHostname().size() + 1];
- strncpy(hosts[i][j], ppDNInfo.getHostname().c_str(), ppDNInfo.getHostname().size() + 1);
- }
- hosts[i][ppDNInfos.size()] = nullptr;
- }
- hosts[ppBlockLocations.size()] = nullptr;
- return hosts;
- } catch (const std::exception & e) {
- ReportException(e);
+ {
+ if (!CheckSystem(fs)) {
+ return nullptr;
+ }
+ const optional<std::string> abs_path = getAbsolutePath(fs, path);
+ if(!abs_path) {
return nullptr;
- } catch (...) {
- ReportCaughtNonException();
+ }
+ std::shared_ptr<FileBlockLocation> ppLocations;
+ Status stat = fs->get_impl()->GetBlockLocations(*abs_path, start, length, &ppLocations);
+ if (!stat.ok()) {
+ Error(stat);
return nullptr;
}
+ const std::vector<BlockLocation> & ppBlockLocations = ppLocations->getBlockLocations();
+ char ***hosts = new char**[ppBlockLocations.size() + 1];
+ for (size_t i=0; i < ppBlockLocations.size(); i++) {
+ const std::vector<DNInfo> & ppDNInfos = ppBlockLocations[i].getDataNodes();
+ hosts[i] = new char*[ppDNInfos.size() + 1];
+ for (size_t j=0; j < ppDNInfos.size(); j++) {
+ auto ppDNInfo = ppDNInfos[j];
+ hosts[i][j] = new char[ppDNInfo.getHostname().size() + 1];
+ strncpy(hosts[i][j], ppDNInfo.getHostname().c_str(), ppDNInfo.getHostname().size() + 1);
+ }
+ hosts[i][ppDNInfos.size()] = nullptr;
+ }
+ hosts[ppBlockLocations.size()] = nullptr;
+ return hosts;
+ } catch (const std::exception & e) {
+ ReportException(e);
+ return nullptr;
+ } catch (...) {
+ ReportCaughtNonException();
+ return nullptr;
+ }
}
+HDFS_API
void hdfsFreeHosts(char ***blockHosts) {
- errno = 0;
+ resetErrorForApiCall("hdfsFreeHosts");
if (blockHosts == nullptr)
return;
@@ -1495,16 +1492,20 @@ event_response file_callback_glue(libhdfspp_file_event_callback handler,
return event_response::ok();
}
+HDFS_EXT_API
int hdfsPreAttachFSMonitor(libhdfspp_fs_event_callback handler, int64_t cookie)
{
+ resetErrorForApiCall("hdfsPreAttachFSMonitor");
fs_event_callback callback = std::bind(fs_callback_glue, handler, cookie, _1, _2, _3);
fsEventCallback = callback;
return 0;
}
+HDFS_EXT_API
int hdfsPreAttachFileMonitor(libhdfspp_file_event_callback handler, int64_t cookie)
{
+ resetErrorForApiCall("hdfsPreAttachFileMonitor");
file_event_callback callback = std::bind(file_callback_glue, handler, cookie, _1, _2, _3, _4);
fileEventCallback = callback;
return 0;
@@ -1541,11 +1542,12 @@ hdfsBuilder::hdfsBuilder(const char * directory) :
config = LoadDefault(loader);
}
+HDFS_API
struct hdfsBuilder *hdfsNewBuilder(void)
{
+ resetErrorForApiCall("hdfsNewBuilder");
try
{
- errno = 0;
return new struct hdfsBuilder();
} catch (const std::exception & e) {
ReportException(e);
@@ -1556,37 +1558,42 @@ struct hdfsBuilder *hdfsNewBuilder(void)
}
}
+HDFS_API
void hdfsBuilderSetNameNode(struct hdfsBuilder *bld, const char *nn)
{
- errno = 0;
+ resetErrorForApiCall("hdfsBuilderSetNameNode");
bld->overrideHost = std::string(nn);
}
+HDFS_API
void hdfsBuilderSetNameNodePort(struct hdfsBuilder *bld, tPort port)
{
- errno = 0;
+ resetErrorForApiCall("hdfsBuilderSetNameNodePort");
bld->overridePort = port;
}
+HDFS_API
void hdfsBuilderSetUserName(struct hdfsBuilder *bld, const char *userName)
{
- errno = 0;
+ resetErrorForApiCall("hdfsBuilderSetUserName");
if (userName && *userName) {
bld->user = std::string(userName);
}
}
+HDFS_API
void hdfsBuilderSetForceNewInstance(struct hdfsBuilder *bld) {
+ resetErrorForApiCall("hdfsBuilderSetForceNewInstance");
//libhdfspp always returns a new instance, so nothing to do
(void)bld;
- errno = 0;
}
+HDFS_API
void hdfsFreeBuilder(struct hdfsBuilder *bld)
{
+ resetErrorForApiCall("hdfsFreeBuilder");
try
{
- errno = 0;
delete bld;
} catch (const std::exception & e) {
ReportException(e);
@@ -1595,12 +1602,12 @@ void hdfsFreeBuilder(struct hdfsBuilder *bld)
}
}
-int hdfsBuilderConfSetStr(struct hdfsBuilder *bld, const char *key,
- const char *val)
+HDFS_API
+int hdfsBuilderConfSetStr(struct hdfsBuilder *bld, const char *key, const char *val)
{
+ resetErrorForApiCall("hdfsBuilderConfSetStr");
try
{
- errno = 0;
optional<HdfsConfiguration> newConfig = bld->loader.OverlayValue(bld->config, key, val);
if (newConfig)
{
@@ -1612,6 +1619,17 @@ int hdfsBuilderConfSetStr(struct hdfsBuilder *bld, const char *key,
ReportError(EINVAL, "Could not change Builder value");
return -1;
}
+ } CATCH_AND_REPORT
+}
+
+HDFS_API
+int hdfsConfGetStr(const char *key, char **val)
+{
+ resetErrorForApiCall("hdfsConfGetStr");
+ try
+ {
+ hdfsBuilder builder;
+ return hdfsBuilderConfGetStr(&builder, key, val);
} catch (const std::exception & e) {
return ReportException(e);
} catch (...) {
@@ -1619,52 +1637,39 @@ int hdfsBuilderConfSetStr(struct hdfsBuilder *bld, const char *key,
}
}
+HDFS_API
void hdfsConfStrFree(char *val)
{
- errno = 0;
+ resetErrorForApiCall("hdfsConfStrFree");
free(val);
}
+HDFS_API
hdfsFS hdfsBuilderConnect(struct hdfsBuilder *bld) {
+ resetErrorForApiCall("hdfsBuilderConnect");
return doHdfsConnect(bld->overrideHost, bld->overridePort, bld->user, bld->config.GetOptions());
}
-int hdfsConfGetStr(const char *key, char **val)
-{
- try
- {
- errno = 0;
- hdfsBuilder builder;
- return hdfsBuilderConfGetStr(&builder, key, val);
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
- }
-}
-
+HDFS_API
int hdfsConfGetInt(const char *key, int32_t *val)
{
+ resetErrorForApiCall("hdfsConfGetInt");
try
{
- errno = 0;
hdfsBuilder builder;
return hdfsBuilderConfGetInt(&builder, key, val);
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
- }
+ } CATCH_AND_REPORT
}
//
// Extended builder interface
//
+HDFS_EXT_API
struct hdfsBuilder *hdfsNewBuilderFromDirectory(const char * configDirectory)
{
+ resetErrorForApiCall("hdfsNewBuilderFromDirectory");
try
{
- errno = 0;
return new struct hdfsBuilder(configDirectory);
} catch (const std::exception & e) {
ReportException(e);
@@ -1675,12 +1680,12 @@ struct hdfsBuilder *hdfsNewBuilderFromDirectory(const char * configDirectory)
}
}
-int hdfsBuilderConfGetStr(struct hdfsBuilder *bld, const char *key,
- char **val)
+HDFS_EXT_API
+int hdfsBuilderConfGetStr(struct hdfsBuilder *bld, const char *key, char **val)
{
+ resetErrorForApiCall("hdfsBuilderConfGetStr");
try
{
- errno = 0;
optional<std::string> value = bld->config.Get(key);
if (value)
{
@@ -1693,11 +1698,7 @@ int hdfsBuilderConfGetStr(struct hdfsBuilder *bld, const char *key,
*val = nullptr;
}
return 0;
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
- }
+ } CATCH_AND_REPORT
}
// If we're running on a 32-bit platform, we might get 64-bit values that
@@ -1708,11 +1709,12 @@ bool isValidInt(int64_t value)
value <= std::numeric_limits<int>::max());
}
+HDFS_EXT_API
int hdfsBuilderConfGetInt(struct hdfsBuilder *bld, const char *key, int32_t *val)
{
+ resetErrorForApiCall("hdfsBuilderConfGetInt");
try
{
- errno = 0;
// Pull from default configuration
optional<int64_t> value = bld->config.GetInt(key);
if (value)
@@ -1727,18 +1729,15 @@ int hdfsBuilderConfGetInt(struct hdfsBuilder *bld, const char *key, int32_t *val
// If not found, don't change val
ReportError(EINVAL, "Could not get Builder value");
return 0;
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
- }
+ } CATCH_AND_REPORT
}
+HDFS_EXT_API
int hdfsBuilderConfGetLong(struct hdfsBuilder *bld, const char *key, int64_t *val)
{
+ resetErrorForApiCall("hdfsBuilderConfGetLong");
try
{
- errno = 0;
// Pull from default configuration
optional<int64_t> value = bld->config.GetInt(key);
if (value)
@@ -1749,11 +1748,7 @@ int hdfsBuilderConfGetLong(struct hdfsBuilder *bld, const char *key, int64_t *va
// If not found, don't change val
ReportError(EINVAL, "Could not get Builder value");
return 0;
- } catch (const std::exception & e) {
- return ReportException(e);
- } catch (...) {
- return ReportCaughtNonException();
- }
+ } CATCH_AND_REPORT
}
/**
@@ -1829,15 +1824,21 @@ void CForwardingLogger::FreeLogData(LogData *data) {
}
+HDFS_EXT_API
LogData *hdfsCopyLogData(LogData *data) {
+ resetErrorForApiCall("hdfsCopyLogData");
return CForwardingLogger::CopyLogData(data);
}
+HDFS_EXT_API
void hdfsFreeLogData(LogData *data) {
+ resetErrorForApiCall("hdfsFreeLogData");
CForwardingLogger::FreeLogData(data);
}
+HDFS_EXT_API
void hdfsSetLogFunction(void (*callback)(LogData*)) {
+ resetErrorForApiCall("hdfsSetLogFunction");
CForwardingLogger *logger = new CForwardingLogger();
logger->SetCallback(callback);
LogManager::SetLoggerImplementation(std::unique_ptr<LoggerInterface>(logger));
@@ -1849,8 +1850,8 @@ static bool IsLevelValid(int component) {
return true;
}
-
// should use __builtin_popcnt as optimization on some platforms
+// *but maybe not Intel: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=62011
static int popcnt(int val) {
int bits = sizeof(val) * 8;
int count = 0;
@@ -1869,24 +1870,27 @@ static bool IsComponentValid(int component) {
return true;
}
+HDFS_EXT_API
int hdfsEnableLoggingForComponent(int component) {
- errno = 0;
+ resetErrorForApiCall("hdfsEnableLoggingForComponent");
if(!IsComponentValid(component))
return -1;
LogManager::EnableLogForComponent(static_cast<LogSourceComponent>(component));
return 0;
}
+HDFS_EXT_API
int hdfsDisableLoggingForComponent(int component) {
- errno = 0;
+ resetErrorForApiCall("hdfsDisableLoggingForComponent");
if(!IsComponentValid(component))
return -1;
LogManager::DisableLogForComponent(static_cast<LogSourceComponent>(component));
return 0;
}
+HDFS_EXT_API
int hdfsSetLoggingLevel(int level) {
- errno = 0;
+ resetErrorForApiCall("hdfsSetLoggingLevel");
if(!IsLevelValid(level))
return -1;
LogManager::SetLogLevel(static_cast<LogLevel>(level));
---------------------------------------------------------------------
To unsubscribe, e-mail: common-commits-unsubscribe@hadoop.apache.org
For additional commands, e-mail: common-commits-help@hadoop.apache.org