Posix Namespace Reference

Functions
std::pair< int, XRootDStatus >	_PRead (Davix::DavPosix &davix_client, DAVIX_FD *fd, void *buffer, uint32_t size, uint64_t offset, bool no_pread=false)
XRootDStatus	Close (Davix::DavPosix &davix_client, DAVIX_FD *fd)
std::pair< XrdCl::DirectoryList *, XrdCl::XRootDStatus >	DirList (Davix::DavPosix &davix_client, const std::string &path, bool details, bool, uint16_t timeout)
XRootDStatus	MkDir (Davix::DavPosix &davix_client, const std::string &path, XrdCl::MkDirFlags::Flags flags, XrdCl::Access::Mode, uint16_t timeout)
std::pair< DAVIX_FD *, XRootDStatus >	Open (Davix::DavPosix &davix_client, const std::string &url, int flags, uint16_t timeout)
std::pair< int, XRootDStatus >	PRead (Davix::DavPosix &davix_client, DAVIX_FD *fd, void *buffer, uint32_t size, uint64_t offset)
std::pair< int, XrdCl::XRootDStatus >	PReadVec (Davix::DavPosix &davix_client, DAVIX_FD *fd, const XrdCl::ChunkList &chunks, void *buffer)
std::pair< int, XrdCl::XRootDStatus >	PWrite (Davix::DavPosix &davix_client, DAVIX_FD *fd, uint64_t offset, uint32_t size, const void *buffer, uint16_t timeout)
std::pair< int, XRootDStatus >	Read (Davix::DavPosix &davix_client, DAVIX_FD *fd, void *buffer, uint32_t size)
XRootDStatus	Rename (Davix::DavPosix &davix_client, const std::string &source, const std::string &dest, uint16_t timeout)
XRootDStatus	RmDir (Davix::DavPosix &davix_client, const std::string &path, uint16_t timeout)
XRootDStatus	Stat (Davix::DavPosix &davix_client, const std::string &url, uint16_t timeout, StatInfo *stat_info)
XRootDStatus	Unlink (Davix::DavPosix &davix_client, const std::string &url, uint16_t timeout)

Function Documentation

_PRead()

std::pair< int, XRootDStatus > Posix::_PRead	(	Davix::DavPosix &	davix_client,
		DAVIX_FD *	fd,
		void *	buffer,
		uint32_t	size,
		uint64_t	offset,
		bool	no_pread = false )

Definition at line 422 of file XrdClHttpPosix.cc.

                                                                            {
  Davix::DavixError* err = nullptr;
  int num_bytes_read;
  if (no_pread) { // continue reading from the current offset position
    num_bytes_read = davix_client.read(fd, buffer, size, &err); 
  }
  else {
    num_bytes_read = davix_client.pread(fd, buffer, size, offset, &err);
  }
  if (num_bytes_read < 0) {
    auto errStatus =
        XRootDStatus(stError, errInternal, err->getStatus(), err->getErrMsg());
    delete err;
    return std::make_pair(num_bytes_read, errStatus);
  }
 
  return std::make_pair(num_bytes_read, XRootDStatus());
}

References XrdCl::errInternal, and XrdCl::stError.

Referenced by PRead(), and Read().

Here is the caller graph for this function:

Close()

XrdCl::XRootDStatus Posix::Close	(	Davix::DavPosix &	davix_client,
		DAVIX_FD *	fd )

Definition at line 220 of file XrdClHttpPosix.cc.

                                                              {
  Davix::DavixError* err = nullptr;
  if (davix_client.close(fd, &err)) {
    auto errStatus =
        XRootDStatus(stError, errInternal, err->getStatus(), err->getErrMsg());
    delete err;
    return errStatus;
  }
 
  return XRootDStatus();
}

References XrdCl::errInternal, and XrdCl::stError.

DirList()

std::pair< XrdCl::DirectoryList *, XrdCl::XRootDStatus > Posix::DirList	(	Davix::DavPosix &	davix_client,
		const std::string &	path,
		bool	details,
		bool	,
		uint16_t	timeout )

Definition at line 299 of file XrdClHttpPosix.cc.

                              {
  Davix::RequestParams params;
  SetTimeout(params, timeout);
  SetAuthz(params);
 
  auto dir_list = new DirectoryList();
 
  Davix::DavixError* err = nullptr;
 
  auto dir_fd = davix_client.opendirpp(&params, SanitizedURL(path), &err);
  if (!dir_fd) {
    auto errStatus = XRootDStatus(stError, errInternal, err->getStatus(),
                                  err->getErrMsg());
    delete err;
    return std::make_pair(nullptr, errStatus);
  }
 
  struct stat info;
  while (auto entry = davix_client.readdirpp(dir_fd, &info, &err)) {
    if (err) {
      auto errStatus = XRootDStatus(stError, errInternal, err->getStatus(),
                                    err->getErrMsg());
      delete err;
      return std::make_pair(nullptr, errStatus);
    }
 
    StatInfo* stat_info = nullptr;
    if (details) {
      stat_info = new StatInfo();
      auto res = FillStatInfo(info, stat_info);
      if (res.IsError()) {
        delete entry;
        delete stat_info;
        return std::make_pair(nullptr, res);
      }
    }
 
    auto list_entry = new DirectoryList::ListEntry(path, entry->d_name, stat_info);
    dir_list->Add(list_entry);
 
    // do not delete "entry". davix_client.readdirpp() always return the same address
    // and will set it to NULL when there is no more directory entry to return 
    //delete entry;
  }
 
  if (davix_client.closedirpp(dir_fd, &err)) {
    auto errStatus = XRootDStatus(stError, errInternal, err->getStatus(),
                                  err->getErrMsg());
    delete err;
    return std::make_pair(nullptr, errStatus);
  }
 
  return std::make_pair(dir_list, XRootDStatus());
}

References XrdCl::errInternal, stat, and XrdCl::stError.

MkDir()

XrdCl::XRootDStatus Posix::MkDir	(	Davix::DavPosix &	davix_client,
		const std::string &	path,
		XrdCl::MkDirFlags::Flags	flags,
		XrdCl::Access::Mode	,
		uint16_t	timeout )

Definition at line 232 of file XrdClHttpPosix.cc.

                                     {
 
  return XRootDStatus();
 
  Davix::RequestParams params;
  SetTimeout(params, timeout);
  SetAuthz(params);
 
  auto DoMkDir = [&davix_client, &params](const std::string& path) {
    Davix::DavixError* err = nullptr;
    if (davix_client.mkdir(&params, SanitizedURL(path), S_IRWXU, &err) &&
        (err->getStatus() != Davix::StatusCode::FileExist)) {
      auto errStatus = XRootDStatus(stError, errInternal, err->getStatus(),
                                    err->getErrMsg());
      delete err;
      return errStatus;
    } else {
      return XRootDStatus();
    }
  };
 
  auto url = XrdCl::URL(path);
 
  if (flags & XrdCl::MkDirFlags::MakePath) {
    // Also create intermediate directories
 
    auto dirs = SplitString(url.GetPath(), "/");
 
    std::string dirs_cumul;
    for (const auto& d : dirs) {
      dirs_cumul += "/" + d;
      url.SetPath(dirs_cumul);
      auto status = DoMkDir(url.GetLocation());
      if (status.IsError()) {
        return status;
      }
    }
  } else {
    // Only create final directory
    auto status = DoMkDir(url.GetURL());
    if (status.IsError()) {
      return status;
    }
  }
 
  return XRootDStatus();
}

References DoMkDir(), XrdCl::errInternal, XrdCl::MkDirFlags::MakePath, and XrdCl::stError.

Here is the call graph for this function:

Open()

std::pair< DAVIX_FD *, XrdCl::XRootDStatus > Posix::Open	(	Davix::DavPosix &	davix_client,
		const std::string &	url,
		int	flags,
		uint16_t	timeout )

Definition at line 200 of file XrdClHttpPosix.cc.

                                                          {
  Davix::RequestParams params;
  SetTimeout(params, timeout);
  SetAuthz(params);
  Davix::DavixError* err = nullptr;
  DAVIX_FD* fd = davix_client.open(&params, SanitizedURL(url), flags, &err);
  XRootDStatus status;
  if (!fd) {
    auto res = ErrCodeConvert(err->getStatus());
    status = XRootDStatus(stError, res.first, res.second, err->getErrMsg());
    delete err;
  }
  else {
    status = XRootDStatus();
  }
  return std::make_pair(fd, status);
}

References XrdCl::stError.

PRead()

std::pair< int, XrdCl::XRootDStatus > Posix::PRead	(	Davix::DavPosix &	davix_client,
		DAVIX_FD *	fd,
		void *	buffer,
		uint32_t	size,
		uint64_t	offset )

Definition at line 448 of file XrdClHttpPosix.cc.

                                                                                 {
  return _PRead(davix_client, fd, buffer, size, offset, false);
}

References _PRead().

Referenced by XrdCl::HttpFilePlugIn::Read().

Here is the call graph for this function:

Here is the caller graph for this function:

PReadVec()

std::pair< int, XrdCl::XRootDStatus > Posix::PReadVec	(	Davix::DavPosix &	davix_client,
		DAVIX_FD *	fd,
		const XrdCl::ChunkList &	chunks,
		void *	buffer )

Definition at line 453 of file XrdClHttpPosix.cc.

                                                           {
  const auto num_chunks = chunks.size();
  std::vector<Davix::DavIOVecInput> input_vector(num_chunks);
  std::vector<Davix::DavIOVecOuput> output_vector(num_chunks);
 
  for (size_t i = 0; i < num_chunks; ++i) {
    input_vector[i].diov_offset = chunks[i].offset;
    input_vector[i].diov_size = chunks[i].length;
    input_vector[i].diov_buffer = chunks[i].buffer;
  }
 
  Davix::DavixError* err = nullptr;
  int num_bytes_read = davix_client.preadVec(
      fd, input_vector.data(), output_vector.data(), num_chunks, &err);
  if (num_bytes_read < 0) {
    auto errStatus =
        XRootDStatus(stError, errInternal, err->getStatus(), err->getErrMsg());
    delete err;
    return std::make_pair(num_bytes_read, XRootDStatus(stError, errUnknown));
  }
 
  return std::make_pair(num_bytes_read, XRootDStatus());
}

References XrdCl::errInternal, XrdCl::errUnknown, and XrdCl::stError.

Referenced by XrdCl::HttpFilePlugIn::VectorRead().

Here is the caller graph for this function:

PWrite()

std::pair< int, XrdCl::XRootDStatus > Posix::PWrite	(	Davix::DavPosix &	davix_client,
		DAVIX_FD *	fd,
		uint64_t	offset,
		uint32_t	size,
		const void *	buffer,
		uint16_t	timeout )

Definition at line 480 of file XrdClHttpPosix.cc.

                                                             {
  Davix::DavixError* err = nullptr;
  off_t new_offset = davix_client.lseek(fd, offset, SEEK_SET, &err);
  if (uint64_t(new_offset) != offset) {
    auto errStatus =
        XRootDStatus(stError, errInternal, err->getStatus(), err->getErrMsg());
    delete err;
    return std::make_pair(new_offset, errStatus);
  }
  int num_bytes_written = davix_client.write(fd, buffer, size, &err);
  if (num_bytes_written < 0) {
    auto errStatus =
        XRootDStatus(stError, errInternal, err->getStatus(), err->getErrMsg());
    delete err;
    return std::make_pair(num_bytes_written, errStatus);
  }
 
  return std::make_pair(num_bytes_written, XRootDStatus());
}

References XrdCl::errInternal, and XrdCl::stError.

Referenced by XrdCl::HttpFilePlugIn::Write().

Here is the caller graph for this function:

Read()

std::pair< int, XrdCl::XRootDStatus > Posix::Read	(	Davix::DavPosix &	davix_client,
		DAVIX_FD *	fd,
		void *	buffer,
		uint32_t	size )

Definition at line 443 of file XrdClHttpPosix.cc.

                                                               {
  return _PRead(davix_client, fd, buffer, size, 0, true);
}

References _PRead().

Here is the call graph for this function:

Rename()

XrdCl::XRootDStatus Posix::Rename	(	Davix::DavPosix &	davix_client,
		const std::string &	source,
		const std::string &	dest,
		uint16_t	timeout )

Definition at line 356 of file XrdClHttpPosix.cc.

                                                             {
 
  // most s3 storage systems either:
  // 1. do not support rename, especially for files that were uploaded using multi-part
  // 2. support by copy-n-delete.
  // we could implement copy-n-delete if necessary
  if (getenv("AWS_ACCESS_KEY_ID"))
      return XRootDStatus(stError, errErrorResponse, kXR_Unsupported);
 
  Davix::RequestParams params;
  SetTimeout(params, timeout);
  SetAuthz(params);
 
  Davix::DavixError* err = nullptr;
  if (davix_client.rename(&params, SanitizedURL(source), SanitizedURL(dest), &err)) {
    auto errStatus =
        XRootDStatus(stError, errInternal, err->getStatus(), err->getErrMsg());
    delete err;
    return errStatus;
  }
 
  return XRootDStatus();
}

References XrdCl::errErrorResponse, XrdCl::errInternal, kXR_Unsupported, and XrdCl::stError.

Referenced by XrdCl::HttpFileSystemPlugIn::Mv().

Here is the caller graph for this function:

RmDir()

XrdCl::XRootDStatus Posix::RmDir	(	Davix::DavPosix &	davix_client,
		const std::string &	path,
		uint16_t	timeout )

Definition at line 282 of file XrdClHttpPosix.cc.

                                     {
  Davix::RequestParams params;
  SetTimeout(params, timeout);
  SetAuthz(params);
 
  Davix::DavixError* err = nullptr;
  if (davix_client.rmdir(&params, path, &err)) {
    auto errStatus =
        XRootDStatus(stError, errInternal, err->getStatus(), err->getErrMsg());
    delete err;
    return errStatus;
  }
 
  return XRootDStatus();
}

References XrdCl::errInternal, and XrdCl::stError.

Stat()

XrdCl::XRootDStatus Posix::Stat	(	Davix::DavPosix &	davix_client,
		const std::string &	url,
		uint16_t	timeout,
		StatInfo *	stat_info )

Definition at line 381 of file XrdClHttpPosix.cc.

                                                         {
  Davix::RequestParams params;
  SetTimeout(params, timeout);
  SetAuthz(params);
 
  struct stat stats;
  Davix::DavixError* err = nullptr;
  if (davix_client.stat(&params, SanitizedURL(url), &stats, &err)) {
    auto res = ErrCodeConvert(err->getStatus());
    auto errStatus =
        XRootDStatus(stError, res.first, res.second, err->getErrMsg());
    delete err;
    return errStatus;
  }
 
  auto res = FillStatInfo(stats, stat_info);
  if (res.IsError()) {
    return res;
  }
 
  return XRootDStatus();
}

References stat, and XrdCl::stError.

Unlink()

XrdCl::XRootDStatus Posix::Unlink	(	Davix::DavPosix &	davix_client,
		const std::string &	url,
		uint16_t	timeout )

Definition at line 405 of file XrdClHttpPosix.cc.

                                      {
  Davix::RequestParams params;
  SetTimeout(params, timeout);
  SetAuthz(params);
 
  Davix::DavixError* err = nullptr;
  if (davix_client.unlink(&params, SanitizedURL(url), &err)) {
    auto errStatus =
        XRootDStatus(stError, errInternal, err->getStatus(), err->getErrMsg());
    delete err;
    return errStatus;
  }
 
  return XRootDStatus();
}

References XrdCl::errInternal, and XrdCl::stError.

Referenced by XrdCl::HttpFilePlugIn::Open(), and XrdCl::HttpFileSystemPlugIn::Rm().

Here is the caller graph for this function: