XRootD
XrdCl Namespace Reference

Classes

struct  Access
 Access mode. More...
 
struct  Action
 Action. More...
 
class  ActionExecutor
 Executes an action registered in the csv file. More...
 
struct  ActionMetrics
 Metrics struct storing all timing and IO information of an action. More...
 
class  AnyObject
 
class  AppendFileImpl
 AppendFile operation (. More...
 
class  Arg
 
class  Arg< std::string >
 
class  ArgBase
 Base class for Arg. More...
 
class  AssignLastURLHandler
 Wrapper class used to assign last URL. More...
 
class  AssignLBHandler
 Wrapper class used to assign a load balancer. More...
 
class  AsyncDiscardReader
 Object for discarding data. More...
 
class  AsyncHSReader
 Utility class encapsulating reading hand-shake response logic. More...
 
class  AsyncHSWriter
 Utility class encapsulating writing hand-shake request logic. More...
 
class  AsyncMsgReader
 Utility class encapsulating reading response message logic. More...
 
class  AsyncMsgWriter
 Utility class encapsulating writing request logic. More...
 
class  AsyncPageReader
 Object for reading out data from the PgRead response. More...
 
class  AsyncRawReader
 Object for reading out data from the kXR_read response. More...
 
class  AsyncRawReaderIntfc
 Base class for any message's body reader. More...
 
class  AsyncSocketHandler
 
class  AsyncVectorReader
 Object for reading out data from the VectorRead response. More...
 
class  barrier_t
 
struct  BindPrefSelector
 
class  Buffer
 Binary blob representation. More...
 
class  BufferPool
 Buffer pool - to limit memory consumption. More...
 
class  Channel
 A communication channel between the client and the server. More...
 
class  ChannelEventHandler
 Channel event handler. More...
 
class  ChannelHandlerList
 A helper for handling channel event handlers. More...
 
class  CheckpointImpl
 Checkpoint operation (. More...
 
class  CheckSumHelper
 Check sum helper for stdio. More...
 
class  CheckSumManager
 Manage the checksum calc objects. More...
 
class  ChkptWrtImpl
 Checkpointed write operation (. More...
 
class  ChkptWrtVImpl
 Checkpointed WriteV operation (. More...
 
class  ChModImpl
 ChMod operation (. More...
 
class  ChunkHandler
 
struct  ChunkInfo
 Describe a data chunk for vector read. More...
 
class  ClassicCopyJob
 
struct  CloseAction
 Close action. More...
 
class  CloseArchiveImpl
 CloseArchive operation (. More...
 
class  CloseFileImpl
 CloseFile operation (. More...
 
class  CloseImpl
 Close operation (. More...
 
class  ConcreteOperation
 
struct  ConnErrJob
 
class  CopyJob
 Copy job. More...
 
class  CopyProcess
 Copy the data from one point to another. More...
 
struct  CopyProcessImpl
 
class  CopyProgressHandler
 Interface for copy progress notification. More...
 
struct  Ctx
 Utility class for storing a pointer to operation context. More...
 
class  DeepLocateImpl
 DeepLocate operation (. More...
 
class  DefaultEnv
 
class  DelXAttrBulkImpl
 DelXAttr bulk operation (. More...
 
class  DelXAttrFsBulkImpl
 DelXAttr bulk operation (. More...
 
class  DelXAttrFsImpl
 DelXAttr operation (. More...
 
class  DelXAttrImpl
 DelXAttr operation (. More...
 
class  DirectoryList
 Directory list. More...
 
struct  DirListFlags
 DirList flags. More...
 
class  DirListImpl
 DirList operation (. More...
 
class  DlgEnv
 
class  EcHandler
 
class  EcPgReadResponseHandler
 
class  EcPlugInFactory
 Plugin factory. More...
 
class  Env
 
class  ExOpenFuncWrapper
 Lambda wrapper. More...
 
struct  FcntlAction
 Fcntl action. More...
 
class  FcntlImpl
 Fcntl operation (. More...
 
class  File
 A file. More...
 
struct  FileImpl
 
class  FileOperation
 
class  FilePlugIn
 An interface for file plug-ins. More...
 
class  FileStateHandler
 Handle the stateful operations. More...
 
class  FileSystem
 Send file/filesystem queries to an XRootD cluster. More...
 
struct  FileSystemData
 
struct  FileSystemImpl
 Implementation holding the data members. More...
 
class  FileSystemOperation
 
class  FileSystemPlugIn
 An interface for file plug-ins. More...
 
class  FileSystemUtils
 
class  FileTimer
 Task generating timeout events for FileStateHandlers in recovery mode. More...
 
class  FinalOperation
 
class  ForkHandler
 
class  FreeSpace
 
class  FSExecutor
 Execute queries given as a commandline. More...
 
class  FunctionWrapper
 
class  FunctionWrapper< void >
 
class  FutureWrapper
 
class  FutureWrapper< void >
 A wrapper handler for a std::promise / std::future, overload for void type. More...
 
class  FutureWrapperBase
 
struct  Fwd
 
struct  FwdStorage
 
class  GetXAttrBulkImpl
 GetXAttr bulk operation (. More...
 
class  GetXAttrFsBulkImpl
 GetXAttr bulk operation (. More...
 
class  GetXAttrFsImpl
 GetXAttr operation (. More...
 
class  GetXAttrImpl
 GetXAttr operation (. More...
 
class  HandleRspJob
 
struct  HandShakeData
 Data structure that carries the handshake information. More...
 
struct  HostInfo
 
class  HttpFilePlugIn
 
class  HttpFileSystemPlugIn
 
struct  InMessageHelper
 
class  InQueue
 A synchronize queue for incoming data. More...
 
class  Job
 Interface for a job to be run by the job manager. More...
 
class  JobManager
 A synchronized queue. More...
 
class  ListXAttrFsImpl
 ListXAttr bulk operation (. More...
 
class  ListXAttrImpl
 ListXAttr bulk operation (. More...
 
class  LocalFileHandler
 
class  LocalFileTask
 
class  LocateImpl
 Locate operation (. More...
 
class  LocationInfo
 Path location info. More...
 
class  Log
 Handle diagnostics. More...
 
class  LogOut
 Interface for logger outputs. More...
 
class  LogOutCerr
 Write log messages to stderr. More...
 
class  LogOutFile
 Write log messages to a file. More...
 
class  Message
 The message representation used throughout the system. More...
 
struct  MessageSendParams
 
class  MessageUtils
 
class  MetalinkOpenHandler
 
class  MetalinkReadHandler
 
class  MetalinkRedirector
 
struct  MkDirFlags
 MkDir flags. More...
 
class  MkDirImpl
 MkDir operation (. More...
 
class  Monitor
 An abstract class to describe the client-side monitoring plugin interface. More...
 
class  MsgHandler
 Message handler. More...
 
class  MvImpl
 Mv operation (. More...
 
class  mytimer_t
 Timer helper class. More...
 
struct  None
 none object for initializing empty Optional More...
 
struct  NullRef
 
class  NullResponseHandler
 
struct  OpenAction
 Open action. More...
 
class  OpenArchiveImpl
 OpenArchive operation (. More...
 
class  OpenFileImpl
 OpenFile operation (. More...
 
struct  OpenFlags
 Open flags, may be or'd when appropriate. More...
 
class  OpenImpl
 Open operation (. More...
 
class  OpenInfo
 Information returned by file open operation. More...
 
class  Operation
 
class  operation_expired
 
class  Optional
 
class  OutQueue
 A synchronized queue for the outgoing data. More...
 
struct  PageInfo
 
struct  PageInfoImpl
 
class  ParallelOperation
 
struct  PathID
 
struct  PgReadAction
 
struct  PgReadFlags
 PgRead flags. More...
 
class  PgReadImpl
 PgRead operation (. More...
 
class  PgReadSubstitutionHandler
 
struct  PgWriteAction
 
class  PgWriteImpl
 PgWrite operation (. More...
 
class  PingImpl
 Ping operation (. More...
 
class  Pipeline
 
class  PipelineException
 Pipeline exception, wrapps an XRootDStatus. More...
 
class  PipelineHandler
 
class  PlugInFactory
 Plugin factory. More...
 
class  PlugInManager
 Manage client-side plug-ins and match them agains URLs. More...
 
struct  PluginUnloadHandler
 
struct  PolicyExecutor
 
class  Poller
 Interface for socket pollers. More...
 
class  PollerBuiltIn
 A poller implementation using the build-in XRootD poller. More...
 
class  PollerFactory
 Helper for creating poller objects. More...
 
class  PostMaster
 A hub for dispatching and receiving messages. More...
 
struct  PostMasterImpl
 
struct  PrepareFlags
 Prepare flags. More...
 
class  PrepareImpl
 Prepare operation (. More...
 
class  PropertyList
 A key-value pair map storing both keys and values as strings. More...
 
class  ProtocolImpl
 Protocol operation (. More...
 
class  ProtocolInfo
 Protocol response. More...
 
struct  QueryCode
 XRootD query request codes. More...
 
class  QueryImpl
 Query operation (. More...
 
class  RawWrapper
 Wrapper class for raw response handler (ResponseHandler). More...
 
struct  ReadAction
 Read action. More...
 
class  ReadImpl
 Read operation (. More...
 
struct  ReadTrait
 RdWithRsp: factory for creating ReadImpl/PgReadImpl objects. More...
 
struct  ReadTrait< ChunkInfo >
 
struct  ReadTrait< PageInfo >
 
class  Recorder
 
class  RecorderFactory
 XrdCl recorder plug-in factory. More...
 
struct  RedirectEntry
 
class  RedirectJob
 A job class for redirect handling in the thread-pool. More...
 
class  RedirectorRegistry
 Singleton access to URL to virtual redirector mapping. More...
 
class  ReplayArgs
 Args parse for XrdClReplay. More...
 
class  RequestSync
 A helper running a fixed number of requests at a given time. More...
 
struct  Resp
 
struct  Resp< void >
 
struct  RespBase
 
class  ResponseHandler
 Handle an async response. More...
 
class  ResponseJob
 Call the user callback. More...
 
struct  RetryInfo
 
struct  RetryInfoImpl
 
class  RmDirImpl
 RmDir operation (. More...
 
class  RmImpl
 Rm operation (. More...
 
class  ScopedDescriptor
 Smart descriptor - closes the descriptor on destruction. More...
 
class  SendInfoImpl
 SendInfo operation (. More...
 
struct  seq_gen
 
struct  seq_gen< 0, Ns... >
 
struct  seq_gen< I, Ns... >
 
struct  sequence
 
class  ServerSpaceInfo
 
class  SetXAttrBulkImpl
 SetXAttr bulk operation (. More...
 
class  SetXAttrFsBulkImpl
 SetXAttr bulk operation (. More...
 
class  SetXAttrFsImpl
 SetXAttr operation (. More...
 
class  SetXAttrImpl
 SetXAttr operation (. More...
 
class  SIDManager
 Handle XRootD stream IDs. More...
 
class  SIDMgrPool
 Pool of SID manager objects. More...
 
class  Socket
 A network socket. More...
 
class  SocketHandler
 Interface. More...
 
struct  StatAction
 Stat action. More...
 
class  StatFsImpl
 Stat operation (. More...
 
class  StatImpl
 Stat operation (. More...
 
class  StatInfo
 Object stat info. More...
 
struct  StatInfoImpl
 
class  StatInfoVFS
 VFS stat info. More...
 
struct  Status
 Procedure execution status. More...
 
class  StatVFSImpl
 StatVS operation (. More...
 
class  Stream
 Stream. More...
 
struct  StreamQuery
 
struct  StreamSelector
 Selects less loaded stream for read operation over multiple streams. More...
 
struct  SubStreamData
 
struct  SyncAction
 Sync action. More...
 
class  SyncImpl
 Sync operation (. More...
 
class  SyncQueue
 A synchronized queue. More...
 
class  SyncResponseHandler
 Synchronize the response. More...
 
class  Task
 Interface for a task to be run by the TaskManager. More...
 
class  TaskManager
 
class  TaskWrapper
 
class  TaskWrapper< void, Return >
 
class  ThirdPartyCopyJob
 
class  TickGeneratorTask
 
class  Timeout
 
class  Tls
 TLS layer for socket connection. More...
 
class  TPFallBackCopyJob
 
class  TransportHandler
 Perform the handshake and the authentication for each physical stream. More...
 
class  TransportManager
 Manage transport handler objects. More...
 
struct  TransportQuery
 
struct  TruncateAction
 Truncate action. More...
 
class  TruncateFsImpl
 Truncate operation (. More...
 
class  TruncateImpl
 Truncate operation (. More...
 
class  UnpackXAttr
 Helper class for unpacking single XAttr from bulk response. More...
 
class  UnpackXAttrStatus
 Helper class for unpacking single XAttrStatus from bulk response. More...
 
class  URL
 URL representation. More...
 
class  Utils
 Random utilities. More...
 
struct  VectorReadAction
 VectorRead action. More...
 
class  VectorReadImpl
 VectorRead operation (. More...
 
class  VectorReadInfo
 Vector read info. More...
 
struct  VectorWriteAction
 Vector Write action. More...
 
class  VectorWriteImpl
 VectorWrite operation (. More...
 
class  VirtualRedirector
 An interface for metadata redirectors. More...
 
class  VisaImpl
 Visa operation (. More...
 
struct  WriteAction
 Write action. More...
 
class  WriteImpl
 Write operation (. More...
 
class  WriteVImpl
 WriteV operation (. More...
 
struct  XAttr
 Extended attributes with status. More...
 
struct  XAttrStatus
 Extended attribute operation status. More...
 
class  XCpCtx
 
class  XCpSrc
 
struct  XRootDChannelInfo
 Information holder for xrootd channels. More...
 
class  XRootDMsgHandler
 Handle/Process/Forward XRootD messages. More...
 
struct  XRootDQuery
 XRootD related protocol queries. More...
 
class  XRootDStatus
 Request status. More...
 
struct  XRootDStreamInfo
 Information holder for XRootDStreams. More...
 
class  XRootDTransport
 XRootD transport handler. More...
 
class  ZipArchive
 
class  ZipCache
 Utility class for inflating a compressed buffer. More...
 
struct  ZipError
 An exception for carrying the XRootDStatus of InflCache. More...
 
class  ZipListHandler
 
class  ZipListImpl
 ZipList operation (. More...
 
class  ZipOperation
 
class  ZipReadFromImpl
 Read operation (. More...
 
class  ZipReadImpl
 Read operation (. More...
 
class  ZipStatImpl
 ZipStat operation (. More...
 
class  ZipWriteImpl
 Write operation (. More...
 

Typedefs

using action_list = std::multimap< double, ActionExecutor >
 List of actions: start time - action. More...
 
typedef Buffer BinaryDataInfo
 Binary buffer. More...
 
typedef ChModImpl< false > ChMod
 
typedef std::vector< ChunkInfoChunkList
 List of chunks. More...
 
typedef CloseFileImpl< false > CloseFile
 
typedef DeepLocateImpl< false > DeepLocate
 
typedef DirListImpl< false > DirList
 
typedef FcntlImpl< false > Fcntl
 
typedef FinalOperation Final
 
typedef std::vector< HostInfoHostList
 
typedef LocateImpl< false > Locate
 
typedef MkDirImpl< false > MkDir
 
typedef MvImpl< false > Mv
 
typedef PingImpl< false > Ping
 
typedef PrepareImpl< false > Prepare
 
typedef ProtocolImpl< false > Protocol
 
typedef QueryImpl< false > Query
 
typedef std::function< Operation< true > *(const XRootDStatus &)> rcvry_func
 Type of the recovery function to be provided by the user. More...
 
typedef RmImpl< false > Rm
 
typedef RmDirImpl< false > RmDir
 
typedef SendInfoImpl< false > SendInfo
 
typedef StatVFSImpl< false > StatVFS
 
typedef VisaImpl< false > Visa
 
typedef std::tuple< std::string, std::string > xattr_t
 Extended attribute key - value pair. More...
 

Enumerations

enum  {
  xattr_name = 0 ,
  xattr_value = 1
}
 Tuple indexes of name and value fields in xattr_t. More...
 
enum  ChkPtCode {
  BEGIN = kXR_ckpBegin ,
  COMMIT = kXR_ckpCommit ,
  ROLLBACK = kXR_ckpRollback
}
 Checkpoint operation code. More...
 

Functions

AppendFileImpl< false > AppendFile (Ctx< ZipArchive > zip, Arg< std::string > fn, Arg< uint32_t > crc32, Arg< uint32_t > size, Arg< const void * > buffer, uint16_t timeout=0)
 Factory for creating ArchiveReadImpl objects. More...
 
template<typename FUNC , typename ... ARGs>
static auto Apply (FUNC &&func, std::tuple< ARGs... > &tup) -> decltype(tuple_call_impl(func, tup, typename seq_gen< sizeof...(ARGs)>::type{}))
 
template<typename METH , typename OBJ , typename ... ARGs>
static auto Apply (METH &&method, OBJ &obj, std::tuple< ARGs... > &tup) -> decltype(Apply(std::bind(method, &obj, std::placeholders::_1, std::placeholders::_2), tup))
 
bool AssureFile (const std::string &url, uint64_t size, bool viatruncate, bool verify)
 AssureFile creates input data files on the fly if required. More...
 
std::future< XRootDStatusAsync (Pipeline pipeline, uint16_t timeout=0)
 
CheckpointImpl< false > Checkpoint (Ctx< File > file, Arg< ChkPtCode > code, uint16_t timeout=0)
 Factory for creating ReadImpl objects. More...
 
ChkptWrtImpl< false > ChkptWrt (Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< const void * > buffer, uint16_t timeout=0)
 Factory for creating ReadImpl objects. More...
 
ChkptWrtVImpl< false > ChkptWrtV (Ctx< File > file, Arg< uint64_t > offset, Arg< std::vector< iovec >> iov, uint16_t timeout=0)
 Factory for creating ChkptWrtVImpl objects. More...
 
CloseImpl< false > Close (Ctx< File > file, uint16_t timeout=0)
 Factory for creating CloseImpl objects. More...
 
CloseArchiveImpl< false > CloseArchive (Ctx< ZipArchive > zip, uint16_t timeout=0)
 Factory for creating CloseFileImpl objects. More...
 
void DeallocArgs (XRootDStatus *status, AnyObject *response, HostList *hostList)
 
DelXAttrImpl< false > DelXAttr (Ctx< File > file, Arg< std::string > name)
 
DelXAttrBulkImpl< false > DelXAttr (Ctx< File > file, Arg< std::vector< std::string >> attrs)
 
DelXAttrFsImpl< false > DelXAttr (Ctx< FileSystem > fs, Arg< std::string > path, Arg< std::string > name)
 
DelXAttrFsBulkImpl< false > DelXAttr (Ctx< FileSystem > fs, Arg< std::string > path, Arg< std::vector< std::string >> attrs)
 
std::thread ExecuteActions (std::unique_ptr< File > file, action_list &&actions, double t0, double speed, ActionMetrics &metric, bool simulate)
 
EcHandlerGetEcHandler (const URL &headnode, const URL &redirurl)
 
template<typename Response >
Response * GetResponse (AnyObject *rsp)
 
template<typename Response >
Response * GetResponse (XRootDStatus *status, AnyObject *rsp)
 
GetXAttrImpl< false > GetXAttr (Ctx< File > file, Arg< std::string > name)
 
GetXAttrBulkImpl< false > GetXAttr (Ctx< File > file, Arg< std::vector< std::string >> attrs)
 
GetXAttrFsImpl< false > GetXAttr (Ctx< FileSystem > fs, Arg< std::string > path, Arg< std::string > name)
 
GetXAttrFsBulkImpl< false > GetXAttr (Ctx< FileSystem > fs, Arg< std::string > path, Arg< std::vector< std::string >> attrs)
 
bool InitTLS ()
 
ZipListImpl< false > List (Ctx< ZipArchive > zip)
 Factory for creating ZipStatImpl objects. More...
 
ListXAttrImpl< false > ListXAttr (Ctx< File > file)
 
ListXAttrFsImpl< false > ListXAttr (Ctx< FileSystem > fs, Arg< std::string > path)
 
template<typename T , typename... Args>
std::shared_ptr< FwdStorage< T > > make_fwd (Args &&... args)
 
OpenImpl< false > Open (Ctx< File > file, Arg< std::string > url, Arg< OpenFlags::Flags > flags, Arg< Access::Mode > mode=Access::None, uint16_t timeout=0)
 Factory for creating ReadImpl objects. More...
 
OpenArchiveImpl< false > OpenArchive (Ctx< ZipArchive > zip, Arg< std::string > fn, Arg< OpenFlags::Flags > flags, uint16_t timeout=0)
 Factory for creating OpenArchiveImpl objects. More...
 
OpenFileImpl< false > OpenFile (Ctx< ZipArchive > zip, Arg< std::string > fn, Arg< OpenFlags::Flags > flags=OpenFlags::None, Arg< uint64_t > size=0, Arg< uint32_t > crc32=0, uint16_t timeout=0)
 Factory for creating OpenFileImpl objects. More...
 
template<class Container >
ParallelOperation< false > Parallel (Container &&container)
 Factory function for creating parallel operation from a vector. More...
 
template<typename ... Operations>
ParallelOperation< false > Parallel (Operations &&... operations)
 
std::unordered_map< File *, action_listParseInput (const std::string &path, double &t0, double &t1, std::unordered_map< File *, std::string > &filenames, std::unordered_map< File *, double > &synchronicity, std::unordered_map< File *, size_t > &responseerrors, const std::vector< std::string > &option_regex)
 
PgReadImpl< false > PgRead (Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout=0)
 Factory for creating PgReadImpl objects. More...
 
PgWriteImpl< false > PgWrite (Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, Arg< std::vector< uint32_t >> cksums, uint16_t timeout=0)
 Factory for creating PgReadImpl objects. More...
 
PgWriteImpl< false > PgWrite (Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout=0)
 Factory for creating PgReadImpl objects. More...
 
void PipesToVec (std::vector< Pipeline > &)
 Helper function for converting parameter pack into a vector. More...
 
template<typename ... Others>
void PipesToVec (std::vector< Pipeline > &v, Operation< false > &operation, Others &... others)
 
template<typename ... Others>
void PipesToVec (std::vector< Pipeline > &v, Operation< true > &operation, Others &... others)
 
template<typename ... Others>
void PipesToVec (std::vector< Pipeline > &v, Pipeline &pipeline, Others &... others)
 
template<>
std::string PropertyList::Get< std::string > (const std::string &name) const
 
template<>
bool PropertyList::Get< std::string > (const std::string &name, std::string &item) const
 
template<>
bool PropertyList::Get< std::vector< std::string > > (const std::string &name, std::vector< std::string > &item) const
 
template<>
void PropertyList::Set< std::vector< std::string > > (const std::string &name, const std::vector< std::string > &item)
 
template<typename RSP >
ReadTrait< RSP >::RET RdWithRsp (Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout=0)
 
template<>
ReadImpl< false > RdWithRsp< ChunkInfo > (Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout)
 
template<>
PgReadImpl< false > RdWithRsp< PageInfo > (Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout)
 
ReadImpl< false > Read (Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout=0)
 Factory for creating ReadImpl objects. More...
 
ZipReadImpl< false > Read (Ctx< ZipArchive > zip, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout=0)
 Factory for creating ArchiveReadImpl objects. More...
 
ZipReadFromImpl< false > ReadFrom (Ctx< ZipArchive > zip, Arg< std::string > fn, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout=0)
 Factory for creating ArchiveReadImpl objects. More...
 
template<typename RSP >
XRootDStatus ReadFromImpl (ZipArchive &me, const std::string &fn, uint64_t relativeOffset, uint32_t size, void *usrbuff, ResponseHandler *usrHandler, uint16_t timeout)
 
void SetUpLogging (Log *logger)
 
SetXAttrImpl< false > SetXAttr (Ctx< File > file, Arg< std::string > name, Arg< std::string > value)
 
SetXAttrBulkImpl< false > SetXAttr (Ctx< File > file, Arg< std::vector< xattr_t >> attrs)
 
SetXAttrFsImpl< false > SetXAttr (Ctx< FileSystem > fs, Arg< std::string > path, Arg< std::string > name, Arg< std::string > value)
 
SetXAttrFsBulkImpl< false > SetXAttr (Ctx< FileSystem > fs, Arg< std::string > path, Arg< std::vector< xattr_t >> attrs)
 
StatImpl< false > Stat (Ctx< File > file, Arg< bool > force, uint16_t timeout=0)
 
StatFsImpl< false > Stat (Ctx< FileSystem > fs, Arg< std::string > path)
 
ZipStatImpl< false > Stat (Ctx< ZipArchive > zip)
 Factory for creating ZipStatImpl objects. More...
 
SyncImpl< false > Sync (Ctx< File > file, uint16_t timeout=0)
 Factory for creating SyncImpl objects. More...
 
template<typename T >
T & To (AnyObject &any)
 
static std::string to_lower (std::string str)
 
std::vector< std::string > ToColumns (const std::string &row)
 Split a row into columns. More...
 
TruncateImpl< false > Truncate (Ctx< File > file, Arg< uint64_t > size, uint16_t timeout)
 
TruncateFsImpl< false > Truncate (Ctx< FileSystem > fs, Arg< std::string > path, Arg< uint64_t > size)
 
template<typename FUNC , typename TUPL , int ... INDICES>
static auto tuple_call_impl (FUNC &func, TUPL &args, sequence< INDICES... >) -> decltype(func(std::move(std::get< INDICES >(args))...))
 
VectorReadImpl< false > VectorRead (Ctx< File > file, Arg< ChunkList > chunks, Arg< void * > buffer, uint16_t timeout=0)
 Factory for creating VectorReadImpl objects. More...
 
VectorReadImpl< false > VectorRead (Ctx< File > file, Arg< ChunkList > chunks, uint16_t timeout=0)
 
VectorWriteImpl< false > VectorWrite (Ctx< File > file, Arg< ChunkList > chunks, uint16_t timeout=0)
 Factory for creating VectorWriteImpl objects. More...
 
XRootDStatus WaitFor (Pipeline pipeline, uint16_t timeout=0)
 
WriteImpl< false > Write (Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< const void * > buffer, uint16_t timeout=0)
 Factory for creating WriteImpl objects. More...
 
ZipWriteImpl< false > Write (Ctx< ZipArchive > zip, Arg< uint32_t > size, Arg< const void * > buffer, uint16_t timeout=0)
 Factory for creating ArchiveReadImpl objects. More...
 
WriteVImpl< false > WriteV (Ctx< File > file, Arg< uint64_t > offset, Arg< std::vector< iovec >> iov, uint16_t timeout=0)
 Factory for creating WriteVImpl objects. More...
 

Variables

const uint64_t AppMsg = 0x0000000000000001ULL
 
const uint64_t AsyncSockMsg = 0x0000000000000200ULL
 
const int DefaultAioSignal = 0
 
const char *const DefaultClConfDir = ""
 
const char *const DefaultClConfFile = ""
 
const char *const DefaultClientMonitor = ""
 
const char *const DefaultClientMonitorParam = ""
 
const int DefaultConnectionRetry = 5
 
const int DefaultConnectionWindow = 120
 
const int DefaultCPChunkSize = 8388608
 
const int DefaultCPInitTimeout = 600
 
const int DefaultCPParallelChunks = 4
 
const int DefaultCpRetry = 0
 
const char *const DefaultCpRetryPolicy = "force"
 
const char *const DefaultCpTarget = ""
 
const int DefaultCPTimeout = 0
 
const int DefaultCPTPCTimeout = 1800
 
const int DefaultCpUsePgWrtRd = 1
 
const int DefaultDataServerTTL = 300
 
const char *const DefaultGlfnRedirector = ""
 
const int DefaultIPNoShuffle = 0
 
const int DefaultLoadBalancerTTL = 1200
 
const int DefaultLocalMetalinkFile = 0
 
const int DefaultMaxMetalinkWait = 60
 
const int DefaultMetalinkProcessing = 1
 
const int DefaultMultiProtocol = 0
 
const char *const DefaultNetworkStack = "IPAuto"
 
const int DefaultNoDelay = 1
 
const int DefaultNotAuthorizedRetryLimit = 3
 
const int DefaultNoTlsOK = 0
 
const char *const DefaultOpenRecovery = "true"
 
const int DefaultParallelEvtLoop = 10
 
const char *const DefaultPlugIn = ""
 
const char *const DefaultPlugInConfDir = ""
 
const char *const DefaultPollerPreference = "built-in"
 
const int DefaultPreferIPv4 = 0
 
const int DefaultPreserveLocateTried = 1
 
const int DefaultPreserveXAttrs = 0
 
const char *const DefaultReadRecovery = "true"
 
const int DefaultRedirectLimit = 16
 
const int DefaultRequestTimeout = 1800
 
const int DefaultRetryWrtAtLBLimit = 3
 
const int DefaultRunForkHandler = 1
 
const int DefaultStreamErrorWindow = 1800
 
const int DefaultStreamTimeout = 60
 
const int DefaultSubStreamsPerChannel = 1
 
const int DefaultTCPKeepAlive = 0
 
const int DefaultTCPKeepAliveInterval = 75
 
const int DefaultTCPKeepAliveProbes = 9
 
const int DefaultTCPKeepAliveTime = 7200
 
const int DefaultTimeoutResolution = 15
 
const char *const DefaultTlsDbgLvl = "OFF"
 
const int DefaultTlsMetalink = 0
 
const int DefaultTlsNoData = 0
 
const int DefaultWantTlsOnNoPgrw = 0
 
const int DefaultWorkerThreads = 3
 
const char *const DefaultWriteRecovery = "true"
 
const int DefaultXCpBlockSize = 134217728
 
const int DefaultXRateThreshold = 0
 
const int DefaultZipMtlnCksum = 0
 
const uint16_t errAuthFailed = 204
 
const uint16_t errCheckSumError = 305
 
const uint16_t errConfig = 6
 System misconfigured. More...
 
const uint16_t errConnectionError = 108
 
const uint16_t errCorruptedHeader = 307
 
const uint16_t errDataError = 14
 data is corrupted More...
 
const uint16_t errErrorResponse = 400
 
const uint16_t errFcntl = 4
 failed manipulate file descriptor More...
 
const uint16_t errHandShakeFailed = 202
 
const uint16_t errInProgress = 10
 
const uint16_t errInternal = 7
 Internal error. More...
 
const uint16_t errInvalidAddr = 101
 
const uint16_t errInvalidArgs = 9
 
const uint16_t errInvalidMessage = 201
 
const uint16_t errInvalidOp = 3
 
const uint16_t errInvalidRedirectURL = 302
 
const uint16_t errInvalidResponse = 303
 
const uint16_t errInvalidSession = 109
 
const uint16_t errLocalError = 402
 
const uint16_t errLoginFailed = 203
 
const uint16_t errNoMoreFreeSIDs = 301
 
const uint16_t errNoMoreReplicas = 16
 No more replicas to try. More...
 
const uint16_t errNone = 0
 No error. More...
 
const uint16_t errNotFound = 304
 
const uint16_t errNotImplemented = 15
 Operation is not implemented. More...
 
const uint16_t errNotSupported = 13
 
const uint16_t errOperationExpired = 206
 
const uint16_t errOperationInterrupted = 207
 
const uint16_t errOSError = 12
 
const uint16_t errPipelineFailed = 17
 Pipeline failed and operation couldn't be executed. More...
 
const uint16_t errPoll = 5
 error while polling descriptors More...
 
const uint16_t errPollerError = 105
 
const uint16_t errQueryNotSupported = 205
 
const uint16_t errRedirect = 401
 
const uint16_t errRedirectLimit = 306
 
const uint16_t errResponseNegative = 500
 Query response was negative. More...
 
const uint16_t errRetry = 1
 Try again for whatever reason. More...
 
const uint16_t errSocketDisconnected = 104
 
const uint16_t errSocketError = 102
 
const uint16_t errSocketOptError = 106
 
const uint16_t errSocketTimeout = 103
 
const uint16_t errStreamDisconnect = 107
 
const uint16_t errThresholdExceeded = 208
 
const uint16_t errTlsError = 110
 
const uint16_t errUninitialized = 11
 
const uint16_t errUnknown = 2
 Unknown error. More...
 
const uint16_t errUnknownCommand = 8
 
const uint64_t ExDbgMsg = 0x0000000000001000ULL
 
const uint64_t FileMsg = 0x0000000000000004ULL
 
const uint64_t FileSystemMsg = 0x0000000000000100ULL
 
const uint64_t JobMgrMsg = 0x0000000000000400ULL
 
static const uint64_t kLogXrdClHttp = std::numeric_limits<std::uint64_t>::max()
 
static struct XrdCl::None none
 
const uint64_t PlugInMgrMsg = 0x0000000000000800ULL
 
const uint64_t PollerMsg = 0x0000000000000008ULL
 
const uint64_t PostMasterMsg = 0x0000000000000010ULL
 
Davix::Context * root_ctx_ = NULL
 
Davix::DavPosix * root_davix_client_ = NULL
 
Davix::DavPosix * root_davix_client_file_ = NULL
 
Davix::Context * root_davix_context_ = NULL
 
const uint16_t stError = 0x0001
 An error occurred that could potentially be retried. More...
 
const uint16_t stFatal = 0x0003
 Fatal error, it's still an error. More...
 
const uint16_t stOK = 0x0000
 Everything went OK. More...
 
const uint16_t suAlreadyDone = 4
 
const uint16_t suContinue = 1
 
const uint16_t suDone = 0
 
const uint16_t suNotStarted = 5
 
const uint16_t suPartial = 3
 
const uint16_t suRetry = 2
 
const uint64_t TaskMgrMsg = 0x0000000000000040ULL
 
static std::unordered_map< std::string, int > theDefaultInts
 
static std::unordered_map< std::string, std::string > theDefaultStrs
 
const uint64_t TlsMsg = 0x0000000000002000ULL
 
const uint64_t UtilityMsg = 0x0000000000000002ULL
 
const uint64_t XRootDMsg = 0x0000000000000080ULL
 
const uint64_t XRootDTransportMsg = 0x0000000000000020ULL
 
const uint64_t ZipMsg = 0x0000000000004000ULL
 

Detailed Description

When the envar XRD_CLIENTMONITOR is set to the libpath/libname.so that holds the monitoring object, it is automatically loaded. The following "C" external symbols must exist in the monitor plug-in shared library. It is called to obtain an instance of the XrdCl::Monitor object.

Parameters
execfull path name to executable provided by XrdSysUtils::ExecName
parmsValue of XRD_CLIENTMONITOPARAM envar or null if it is not set.
Returns
Pointer to an instance of XrdCl::Monitor or null which causes monitoring to be disabled.

extern "C" { XrdCl::Monitor *XrdClGetMonitor(const char *exec, const char *parms); }

This file is part of XrdClHttp


Class Documentation

◆ XrdCl::CopyProcessImpl

struct XrdCl::CopyProcessImpl

Definition at line 202 of file XrdClCopyProcess.cc.

+ Collaboration diagram for XrdCl::CopyProcessImpl:
Class Members
vector< PropertyList > pJobProperties
vector< PropertyList * > pJobResults
vector< CopyJob * > pJobs

◆ XrdCl::None

struct XrdCl::None

none object for initializing empty Optional

Definition at line 35 of file XrdClOptional.hh.

+ Collaboration diagram for XrdCl::None:

◆ XrdCl::ReadTrait

struct XrdCl::ReadTrait

template<typename RSP>
struct XrdCl::ReadTrait< RSP >

RdWithRsp: factory for creating ReadImpl/PgReadImpl objects.

Definition at line 342 of file XrdClFileOperations.hh.

+ Collaboration diagram for XrdCl::ReadTrait< RSP >:

◆ XrdCl::ReadTrait< ChunkInfo >

struct XrdCl::ReadTrait< ChunkInfo >

Definition at line 344 of file XrdClFileOperations.hh.

+ Collaboration diagram for XrdCl::ReadTrait< ChunkInfo >:
Class Members
typedef ReadImpl< false > RET

◆ XrdCl::ReadTrait< PageInfo >

struct XrdCl::ReadTrait< PageInfo >

Definition at line 346 of file XrdClFileOperations.hh.

+ Collaboration diagram for XrdCl::ReadTrait< PageInfo >:
Class Members
typedef PgReadImpl< false > RET

◆ XrdCl::seq_gen

struct XrdCl::seq_gen

template<int ... Ns>
struct XrdCl::seq_gen< Ns >

Definition at line 32 of file XrdClApply.hh.

+ Collaboration diagram for XrdCl::seq_gen< Ns >:

◆ XrdCl::seq_gen< 0, Ns... >

struct XrdCl::seq_gen< 0, Ns... >

template<int ... Ns>
struct XrdCl::seq_gen< 0, Ns... >

Definition at line 43 of file XrdClApply.hh.

+ Collaboration diagram for XrdCl::seq_gen< 0, Ns... >:
Class Members
type

◆ XrdCl::seq_gen< I, Ns... >

struct XrdCl::seq_gen< I, Ns... >

template<int I, int ... Ns>
struct XrdCl::seq_gen< I, Ns... >

Definition at line 36 of file XrdClApply.hh.

+ Collaboration diagram for XrdCl::seq_gen< I, Ns... >:
Class Members
type

◆ XrdCl::sequence

struct XrdCl::sequence

template<int ... Is>
struct XrdCl::sequence< Is >

Definition at line 29 of file XrdClApply.hh.

+ Collaboration diagram for XrdCl::sequence< Is >:

Typedef Documentation

◆ action_list

using XrdCl::action_list = typedef std::multimap<double, ActionExecutor>

List of actions: start time - action.

Definition at line 898 of file XrdClReplay.cc.

◆ BinaryDataInfo

Binary buffer.

Definition at line 336 of file XrdClXRootDResponses.hh.

◆ ChMod

typedef ChModImpl<false> XrdCl::ChMod

Definition at line 521 of file XrdClFileSystemOperations.hh.

◆ ChunkList

typedef std::vector<ChunkInfo> XrdCl::ChunkList

List of chunks.

Definition at line 1056 of file XrdClXRootDResponses.hh.

◆ CloseFile

Definition at line 475 of file XrdClZipOperations.hh.

◆ DeepLocate

Definition at line 184 of file XrdClFileSystemOperations.hh.

◆ DirList

typedef DirListImpl<false> XrdCl::DirList

Definition at line 746 of file XrdClFileSystemOperations.hh.

◆ Fcntl

typedef FcntlImpl<false> XrdCl::Fcntl

Definition at line 922 of file XrdClFileOperations.hh.

◆ Final

Definition at line 67 of file XrdClFinalOperation.hh.

◆ HostList

typedef std::vector<HostInfo> XrdCl::HostList

Definition at line 1121 of file XrdClXRootDResponses.hh.

◆ Locate

typedef LocateImpl<false> XrdCl::Locate

Definition at line 136 of file XrdClFileSystemOperations.hh.

◆ MkDir

typedef MkDirImpl<false> XrdCl::MkDir

Definition at line 427 of file XrdClFileSystemOperations.hh.

◆ Mv

typedef MvImpl<false> XrdCl::Mv

Definition at line 232 of file XrdClFileSystemOperations.hh.

◆ Ping

typedef PingImpl<false> XrdCl::Ping

Definition at line 560 of file XrdClFileSystemOperations.hh.

◆ Prepare

typedef PrepareImpl<false> XrdCl::Prepare

Definition at line 843 of file XrdClFileSystemOperations.hh.

◆ Protocol

typedef ProtocolImpl<false> XrdCl::Protocol

Definition at line 698 of file XrdClFileSystemOperations.hh.

◆ Query

typedef QueryImpl<false> XrdCl::Query

Definition at line 280 of file XrdClFileSystemOperations.hh.

◆ rcvry_func

typedef std::function<Operation<true>*(const XRootDStatus&)> XrdCl::rcvry_func

Type of the recovery function to be provided by the user.

Definition at line 57 of file XrdClOperations.hh.

◆ Rm

typedef RmImpl<false> XrdCl::Rm

Definition at line 378 of file XrdClFileSystemOperations.hh.

◆ RmDir

typedef RmDirImpl<false> XrdCl::RmDir

Definition at line 473 of file XrdClFileSystemOperations.hh.

◆ SendInfo

typedef SendInfoImpl<false> XrdCl::SendInfo

Definition at line 793 of file XrdClFileSystemOperations.hh.

◆ StatVFS

typedef StatVFSImpl<false> XrdCl::StatVFS

Definition at line 658 of file XrdClFileSystemOperations.hh.

◆ Visa

typedef VisaImpl<false> XrdCl::Visa

Definition at line 961 of file XrdClFileOperations.hh.

◆ xattr_t

typedef std::tuple<std::string, std::string> XrdCl::xattr_t

Extended attribute key - value pair.

Definition at line 289 of file XrdClXRootDResponses.hh.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Tuple indexes of name and value fields in xattr_t.

Enumerator
xattr_name 
xattr_value 

Definition at line 280 of file XrdClXRootDResponses.hh.

281  {
282  xattr_name = 0,
283  xattr_value = 1
284  };

◆ ChkPtCode

Checkpoint operation code.

Enumerator
BEGIN 
COMMIT 
ROLLBACK 

Definition at line 18 of file XrdClCheckpointOperation.hh.

19  {
21  };
static const int kXR_ckpRollback
Definition: XProtocol.hh:215
static const int kXR_ckpCommit
Definition: XProtocol.hh:213
static const int kXR_ckpBegin
Definition: XProtocol.hh:212

Function Documentation

◆ AppendFile()

AppendFileImpl<false> XrdCl::AppendFile ( Ctx< ZipArchive zip,
Arg< std::string >  fn,
Arg< uint32_t >  crc32,
Arg< uint32_t >  size,
Arg< const void * >  buffer,
uint16_t  timeout = 0 
)
inline

Factory for creating ArchiveReadImpl objects.

Definition at line 421 of file XrdClZipOperations.hh.

424  {
425  return AppendFileImpl<false>( std::move( zip ), std::move( fn ), std::move( crc32 ),
426  std::move( size ), std::move( buffer ) ).Timeout( timeout );
427  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

+ Here is the call graph for this function:

◆ Apply() [1/2]

template<typename FUNC , typename ... ARGs>
static auto XrdCl::Apply ( FUNC &&  func,
std::tuple< ARGs... > &  tup 
) -> decltype( tuple_call_impl( func, tup, typename seq_gen<sizeof...(ARGs)>::type{} ) )
inlinestatic

Definition at line 64 of file XrdClApply.hh.

65  {} ) )
66  {
67  return tuple_call_impl( func, tup, typename seq_gen<sizeof...(ARGs)>::type{} );
68  }
static auto tuple_call_impl(FUNC &func, TUPL &args, sequence< INDICES... >) -> decltype(func(std::move(std::get< INDICES >(args))...))
Definition: XrdClApply.hh:49

Referenced by Apply().

+ Here is the caller graph for this function:

◆ Apply() [2/2]

template<typename METH , typename OBJ , typename ... ARGs>
static auto XrdCl::Apply ( METH &&  method,
OBJ &  obj,
std::tuple< ARGs... > &  tup 
) -> decltype( Apply( std::bind( method, &obj, std::placeholders::_1, std::placeholders::_2 ), tup ) )
inlinestatic

Definition at line 80 of file XrdClApply.hh.

82  {
83  return Apply( std::bind( method, &obj, std::placeholders::_1, std::placeholders::_2 ), tup );
84  }
static auto Apply(METH &&method, OBJ &obj, std::tuple< ARGs... > &tup) -> decltype(Apply(std::bind(method, &obj, std::placeholders::_1, std::placeholders::_2), tup))
Definition: XrdClApply.hh:80

References Apply().

+ Here is the call graph for this function:

◆ AssureFile()

bool XrdCl::AssureFile ( const std::string &  url,
uint64_t  size,
bool  viatruncate,
bool  verify 
)

AssureFile creates input data files on the fly if required.

Definition at line 216 of file XrdClReplay.cc.

217 {
218  OpenFlags::Flags flags = OpenFlags::Read;
219  Access::Mode mode = Access::None;
220  uint16_t timeout = 60;
221 
222  {
223  // deal with existing files
224  auto file = std::make_unique<XrdCl::File>(false);
225  XRootDStatus status = file->Open(url, flags, mode, timeout);
226  if (status.IsOK())
227  {
228  StatInfo* statinfo;
229  // file exists already, verify the size
230  status = file->Stat(false, statinfo, timeout);
231  if (status.IsOK())
232  {
233  if (statinfo->GetSize() < size)
234  {
235  std::cerr
236  << "Error: file size is not sufficient, but I won't touch the file - aborting ...";
237  return false;
238  }
239  else
240  {
241  std::cout << "# ---> info: file exists and has sufficient size" << std::endl;
242  return true;
243  }
244  }
245  }
246  }
247 
248  if (verify)
249  {
250  std::cerr << "Verify: file is missing or inaccessible: " << url << std::endl;
251  return false;
252  }
253 
254  {
255  // deal with non-existing file
256  OpenFlags::Flags wflags = OpenFlags::New | OpenFlags::Write | OpenFlags::MakePath;
257  Access::Mode wmode = Access::UR | Access::UW | Access::UX;
258  auto file = std::make_unique<XrdCl::File>(false);
259  XRootDStatus status = file->Open(url, wflags, wmode, timeout);
260  if (status.IsOK())
261  {
262  if (viatruncate)
263  {
264  // create a file via truncation
265  status = file->Truncate(size, timeout);
266  if (!status.IsOK())
267  {
268  std::cerr << "Error: " << status.ToString() << " - empty file might be left behind!"
269  << std::endl;
270  return false;
271  }
272  return true;
273  }
274  else
275  {
276  // create a file via writes
277  using buffer_t = std::vector<uint64_t>; //< data buffer
278  buffer_t buffer(32768);
279  size_t nbytes = 0;
280 
281  while (nbytes < size)
282  {
283  size_t towrite = size - nbytes;
284  if (towrite > (buffer.size() * sizeof(uint64_t)))
285  towrite = buffer.size() * sizeof(uint64_t);
286  for (size_t i = 0; i < buffer.size(); ++i)
287  {
288  // we write the offset in this buffer
289  buffer[i] = nbytes / sizeof(uint64_t) + i;
290  }
291  status = file->Write(nbytes, towrite, buffer.data(), timeout);
292  if (!status.IsOK())
293  {
294  std::cerr << "Error: " << status.ToString() << " - failed to write file at offset "
295  << nbytes << " - incomplete file might be left behind!" << std::endl;
296  return false;
297  }
298  nbytes += towrite;
299  }
300  }
301  return true;
302  }
303  else
304  {
305  std::cerr << "Error: " << status.ToString() << " - failed to create file!" << std::endl;
306  }
307  }
308  return false;
309 }
int Mode
std::vector< char > buffer_t
a buffer type
Definition: XrdEcReader.hh:45

References XrdCl::StatInfo::GetSize(), XrdCl::Status::IsOK(), XrdCl::OpenFlags::MakePath, XrdCl::OpenFlags::New, XrdCl::Access::None, XrdCl::OpenFlags::Read, XrdCl::Status::ToString(), XrdCl::Access::UR, XrdCl::Access::UW, XrdCl::Access::UX, and XrdCl::OpenFlags::Write.

Referenced by main().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Async()

std::future<XRootDStatus> XrdCl::Async ( Pipeline  pipeline,
uint16_t  timeout = 0 
)
inline

Helper function, schedules execution of given pipeline

Parameters
pipeline: the pipeline to be executed
timeout: the pipeline timeout
Returns
: future status of the operation

Definition at line 522 of file XrdClOperations.hh.

523  {
524  pipeline.Run( timeout );
525  return std::move( pipeline.ftr );
526  }

Referenced by XrdEc::Reader::Close(), XrdCl::ZipArchive::CloseArchive(), DoStat(), XrdCl::ActionExecutor::Execute(), XrdEc::Reader::Open(), XrdEc::StrmWriter::Open(), XrdCl::ZipArchive::OpenArchive(), and WaitFor().

+ Here is the caller graph for this function:

◆ Checkpoint()

CheckpointImpl<false> XrdCl::Checkpoint ( Ctx< File file,
Arg< ChkPtCode code,
uint16_t  timeout = 0 
)
inline

Factory for creating ReadImpl objects.

Definition at line 72 of file XrdClCheckpointOperation.hh.

73  {
74  return CheckpointImpl<false>( std::move( file ), std::move( code ) ).Timeout( timeout );
75  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by XrdCl::ZipArchive::CloseArchive().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ ChkptWrt()

ChkptWrtImpl<false> XrdCl::ChkptWrt ( Ctx< File file,
Arg< uint64_t >  offset,
Arg< uint32_t >  size,
Arg< const void * >  buffer,
uint16_t  timeout = 0 
)
inline

Factory for creating ReadImpl objects.

Definition at line 129 of file XrdClCheckpointOperation.hh.

132  {
133  return ChkptWrtImpl<false>( std::move( file ), std::move( offset ),
134  std::move( size ), std::move( buffer ) ).Timeout( timeout );
135  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

+ Here is the call graph for this function:

◆ ChkptWrtV()

ChkptWrtVImpl<false> XrdCl::ChkptWrtV ( Ctx< File file,
Arg< uint64_t >  offset,
Arg< std::vector< iovec >>  iov,
uint16_t  timeout = 0 
)
inline

Factory for creating ChkptWrtVImpl objects.

Definition at line 197 of file XrdClCheckpointOperation.hh.

200  {
201  return ChkptWrtVImpl<false>( std::move( file ), std::move( offset ),
202  std::move( iov ) ).Timeout( timeout );
203  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

+ Here is the call graph for this function:

◆ Close()

CloseImpl<false> XrdCl::Close ( Ctx< File file,
uint16_t  timeout = 0 
)
inline

Factory for creating CloseImpl objects.

Definition at line 482 of file XrdClFileOperations.hh.

483  {
484  return CloseImpl<false>( std::move( file ) ).Timeout( timeout );
485  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by BIO_XrdLink_destroy(), XrdCl::ZipArchive::CloseArchive(), and XrdCl::ActionExecutor::Execute().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ CloseArchive()

CloseArchiveImpl<false> XrdCl::CloseArchive ( Ctx< ZipArchive zip,
uint16_t  timeout = 0 
)
inline

Factory for creating CloseFileImpl objects.

Definition at line 621 of file XrdClZipOperations.hh.

622  {
623  return CloseArchiveImpl<false>( std::move( zip ) ).Timeout( timeout );
624  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by XrdEc::Reader::Close().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ DeallocArgs()

void XrdCl::DeallocArgs ( XRootDStatus status,
AnyObject response,
HostList hostList 
)

Definition at line 32 of file XrdClMetalinkRedirector.cc.

34  {
35  delete status;
36  delete response;
37  delete hostList;
38  }

Referenced by XrdCl::MetalinkReadHandler::HandleResponse(), and XrdCl::MetalinkOpenHandler::HandleResponseWithHosts().

+ Here is the caller graph for this function:

◆ DelXAttr() [1/4]

DelXAttrImpl<false> XrdCl::DelXAttr ( Ctx< File file,
Arg< std::string >  name 
)
inline

Factory for creating DelXAttrImpl objects (as there is another DelXAttr in FileSystem there would be a clash of typenames).

Definition at line 1256 of file XrdClFileOperations.hh.

1257  {
1258  return DelXAttrImpl<false>( std::move( file ), std::move( name ) );
1259  }

◆ DelXAttr() [2/4]

DelXAttrBulkImpl<false> XrdCl::DelXAttr ( Ctx< File file,
Arg< std::vector< std::string >>  attrs 
)
inline

Factory for creating DelXAttrBulkImpl objects (as there is another DelXAttr in FileSystem there would be a clash of typenames).

Definition at line 1312 of file XrdClFileOperations.hh.

1313  {
1314  return DelXAttrBulkImpl<false>( std::move( file ), std::move( attrs ) );
1315  }

◆ DelXAttr() [3/4]

DelXAttrFsImpl<false> XrdCl::DelXAttr ( Ctx< FileSystem fs,
Arg< std::string >  path,
Arg< std::string >  name 
)
inline

Factory for creating DelXAttrFsImpl objects (as there is another DelXAttr in File there would be a clash of typenames).

Definition at line 1143 of file XrdClFileSystemOperations.hh.

1145  {
1146  return DelXAttrFsImpl<false>( std::move( fs ), std::move( path ), std::move( name ) );
1147  }

◆ DelXAttr() [4/4]

DelXAttrFsBulkImpl<false> XrdCl::DelXAttr ( Ctx< FileSystem fs,
Arg< std::string >  path,
Arg< std::vector< std::string >>  attrs 
)
inline

Factory for creating DelXAttrFsBulkImpl objects (as there is another DelXAttr in FileSystem there would be a clash of typenames).

Definition at line 1201 of file XrdClFileSystemOperations.hh.

1203  {
1204  return DelXAttrFsBulkImpl<false>( std::move( fs ), std::move( path ), std::move( attrs ) );
1205  }

◆ ExecuteActions()

std::thread XrdCl::ExecuteActions ( std::unique_ptr< File file,
action_list &&  actions,
double  t0,
double  speed,
ActionMetrics metric,
bool  simulate 
)

Execute list of actions against given file

Parameters
file: the file object
actions: list of actions to be executed
t0: offset to add to each start time to determine when to ru an action
Returns
: thread that will executed the list of actions

Definition at line 1020 of file XrdClReplay.cc.

1026 {
1027  std::thread t(
1028  [file{ std::move(file) },
1029  actions{ std::move(actions) },
1030  t0,
1031  &metric,
1032  simulate,
1033  &speed]() mutable
1034  {
1035  XrdSysSemaphore endsem(0);
1036  XrdSysSemaphore closesem(0);
1037  auto ending = std::make_shared<barrier_t>(endsem);
1038  auto closing = std::make_shared<barrier_t>(closesem);
1039 
1040  for (auto& p : actions)
1041  {
1042  auto& action = p.second;
1043 
1044  auto tdelay = t0 ? ((p.first + t0) - XrdCl::Action::timeNow()) : 0;
1045  if (tdelay > 0)
1046  {
1047  tdelay /= speed;
1048  metric.delays[action.Name() + "::tloss"] += tdelay;
1049  std::this_thread::sleep_for(std::chrono::milliseconds((int) (tdelay * 1000)));
1050  }
1051  else
1052  {
1053  metric.delays[action.Name() + "::tgain"] += tdelay;
1054  }
1055 
1056  mytimer_t timer;
1057  action.Execute(ending, closing, metric, simulate);
1058  metric.addDelays(action.Name(), "tnomi", action.NominalDuration());
1059  metric.addDelays(action.Name(), "texec", timer.elapsed());
1060  }
1061  ending.reset();
1062  closing.reset();
1063  endsem.Wait();
1064  file->GetProperty("LastURL", metric.url);
1065  file.reset();
1066  });
1067  return t;
1068 }
static double timeNow()
Get curretn unix time in ns precision as a double.
Definition: XrdClAction.hh:78

References XrdCl::ActionMetrics::addDelays(), XrdCl::ActionMetrics::delays, XrdCl::mytimer_t::elapsed(), XrdCl::Action::timeNow(), XrdCl::ActionMetrics::url, and XrdSysSemaphore::Wait().

Referenced by main().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ GetEcHandler()

EcHandler * XrdCl::GetEcHandler ( const URL headnode,
const URL redirurl 
)

Definition at line 166 of file XrdClEcHandler.cc.

167  {
168  const URL::ParamsMap &params = redirurl.GetParams();
169  // make sure all the xrdec. tokens are present and the values are sane
170  URL::ParamsMap::const_iterator itr = params.find( "xrdec.nbdta" );
171  if( itr == params.end() ) return nullptr;
172  uint8_t nbdta = std::stoul( itr->second );
173 
174  itr = params.find( "xrdec.nbprt" );
175  if( itr == params.end() ) return nullptr;
176  uint8_t nbprt = std::stoul( itr->second );
177 
178  itr = params.find( "xrdec.blksz" );
179  if( itr == params.end() ) return nullptr;
180  uint64_t blksz = std::stoul( itr->second );
181 
182  itr = params.find( "xrdec.plgr" );
183  if( itr == params.end() ) return nullptr;
184  std::vector<std::string> plgr;
185  Utils::splitString( plgr, itr->second, "," );
186  if( plgr.size() < nbdta + nbprt ) return nullptr;
187 
188  itr = params.find( "xrdec.objid" );
189  if( itr == params.end() ) return nullptr;
190  std::string objid = itr->second;
191 
192  itr = params.find( "xrdec.format" );
193  if( itr == params.end() ) return nullptr;
194  size_t format = std::stoul( itr->second );
195  if( format != 1 ) return nullptr; // TODO use constant
196 
197  std::vector<std::string> dtacgi;
198  itr = params.find( "xrdec.dtacgi" );
199  if( itr != params.end() )
200  {
201  Utils::splitString( dtacgi, itr->second, "," );
202  if( plgr.size() != dtacgi.size() ) return nullptr;
203  }
204 
205  std::vector<std::string> mdtacgi;
206  itr = params.find( "xrdec.mdtacgi" );
207  if( itr != params.end() )
208  {
209  Utils::splitString( mdtacgi, itr->second, "," );
210  if( plgr.size() != mdtacgi.size() ) return nullptr;
211  }
212 
213  itr = params.find( "xrdec.cosc" );
214  if( itr == params.end() ) return nullptr;
215  std::string cosc_str = itr->second;
216  if( cosc_str != "true" && cosc_str != "false" ) return nullptr;
217  bool cosc = cosc_str == "true";
218 
219  std::string ckstype;
220  itr = params.find( "xrdec.cksum" );
221  if( cosc && itr == params.end() ) return nullptr;
222  if( cosc )
223  ckstype = itr->second;
224 
225  std::string chdigest;
226  itr = params.find( "xrdec.chdigest" );
227  if( itr == params.end() )
228  chdigest = "crc32c";
229  else
230  chdigest = itr->second;
231  bool usecrc32c = ( chdigest == "crc32c" );
232 
233  bool nomtfile = false;
234  itr = params.find( "xrdec.nomtfile" );
235  if( itr != params.end() )
236  nomtfile = ( itr->second == "true" );
237 
238  XrdEc::ObjCfg *objcfg = new XrdEc::ObjCfg( objid, nbdta, nbprt, blksz / nbdta, usecrc32c );
239  objcfg->plgr = std::move( plgr );
240  objcfg->dtacgi = std::move( dtacgi );
241  objcfg->mdtacgi = std::move( mdtacgi );
242  objcfg->nomtfile = nomtfile;
243 
244  std::unique_ptr<CheckSumHelper> cksHelper( cosc ? new CheckSumHelper( "", ckstype ) : nullptr );
245  if( cksHelper )
246  {
247  auto st = cksHelper->Initialize();
248  if( !st.IsOK() ) return nullptr;
249  }
250 
251  return new EcHandler( headnode, objcfg, std::move( cksHelper ) );
252  }
std::vector< std::string > mdtacgi
Definition: XrdEcObjCfg.hh:94
std::vector< std::string > plgr
Definition: XrdEcObjCfg.hh:92
std::vector< std::string > dtacgi
Definition: XrdEcObjCfg.hh:93

References XrdEc::ObjCfg::dtacgi, XrdCl::URL::GetParams(), XrdCl::Status::IsOK(), XrdEc::ObjCfg::mdtacgi, XrdEc::ObjCfg::nomtfile, XrdEc::ObjCfg::plgr, and XrdCl::Utils::splitString().

+ Here is the call graph for this function:

◆ GetResponse() [1/2]

template<typename Response >
Response* XrdCl::GetResponse ( AnyObject rsp)
inline

Unpack response

Parameters
rsp: AnyObject holding response
Returns
: the response

Definition at line 129 of file XrdClOperationHandlers.hh.

130  {
131  Response *ret = nullptr;
132  rsp->Get( ret );
133  return ret;
134  }

References XrdCl::AnyObject::Get().

+ Here is the call graph for this function:

◆ GetResponse() [2/2]

template<typename Response >
Response* XrdCl::GetResponse ( XRootDStatus status,
AnyObject rsp 
)
inline

Unpack response

Parameters
rsp: AnyObject holding response
status:
Returns
: the response

Definition at line 144 of file XrdClOperationHandlers.hh.

145  {
146  if( !status->IsOK() ) return &NullRef<Response>::value;
147  return GetResponse<Response>( rsp );
148  }

References XrdCl::Status::IsOK().

+ Here is the call graph for this function:

◆ GetXAttr() [1/4]

GetXAttrImpl<false> XrdCl::GetXAttr ( Ctx< File file,
Arg< std::string >  name 
)
inline

Factory for creating GetXAttrImpl objects (as there is another GetXAttr in FileSystem there would be a clash of typenames).

Definition at line 1139 of file XrdClFileOperations.hh.

1140  {
1141  return GetXAttrImpl<false>( std::move( file ), std::move( name ) );
1142  }

◆ GetXAttr() [2/4]

GetXAttrBulkImpl<false> XrdCl::GetXAttr ( Ctx< File file,
Arg< std::vector< std::string >>  attrs 
)
inline

Factory for creating GetXAttrBulkImpl objects (as there is another GetXAttr in FileSystem there would be a clash of typenames).

Definition at line 1195 of file XrdClFileOperations.hh.

1196  {
1197  return GetXAttrBulkImpl<false>( std::move( file ), std::move( attrs ) );
1198  }

◆ GetXAttr() [3/4]

GetXAttrFsImpl<false> XrdCl::GetXAttr ( Ctx< FileSystem fs,
Arg< std::string >  path,
Arg< std::string >  name 
)
inline

Factory for creating GetXAttrFsImpl objects (as there is another GetXAttr in File there would be a clash of typenames).

Definition at line 1023 of file XrdClFileSystemOperations.hh.

1025  {
1026  return GetXAttrFsImpl<false>( std::move( fs ), std::move( path ), std::move( name ) );
1027  }

◆ GetXAttr() [4/4]

GetXAttrFsBulkImpl<false> XrdCl::GetXAttr ( Ctx< FileSystem fs,
Arg< std::string >  path,
Arg< std::vector< std::string >>  attrs 
)
inline

Factory for creating GetXAttrFsBulkImpl objects (as there is another GetXAttr in FileSystem there would be a clash of typenames).

Definition at line 1079 of file XrdClFileSystemOperations.hh.

1081  {
1082  return GetXAttrFsBulkImpl<false>( std::move( fs ), std::move( path ), std::move( attrs ) );
1083  }

◆ InitTLS()

bool XrdCl::InitTLS ( )

Initialize TLS context, returns false on failure

Definition at line 96 of file XrdClTls.cc.

97  {
98  static std::mutex tls_mutex;
99  std::lock_guard<std::mutex> tls_lock(tls_mutex);
100 
101  if (tlsContext)
102  return true;
103 
106 
107  int notls = false;
108  env->GetInt("NoTlsOK", notls);
109 
110  if (notls)
111  return false;
112 
113  const char *cadir = getenv("X509_CERT_DIR");
114  const char *cafile = getenv("X509_CERT_FILE");
115 
116  if (!cadir && !cafile)
117  cadir = "/etc/grid-security/certificates";
118 
119  const char *msg;
120  const mode_t camode = S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
121 
122  if (cadir && (msg = XrdOucUtils::ValPath(cadir, camode, true))) {
123  log->Error(XrdCl::TlsMsg, "Failed to initialize TLS context: CA directory %s", msg);
124  env->PutInt("NoTlsOK", 1);
125  return false;
126  }
127 
128  std::string emsg = "unknown error";
129  tlsContext = std::make_unique<XrdTlsContext>(nullptr, nullptr, cadir, cafile, 0ul, &emsg);
130 
131  if (!tlsContext || !tlsContext->isOK()) {
132  tlsContext.reset(nullptr);
133  log->Error(XrdCl::TlsMsg, "Failed to initialize TLS context: %s", emsg.c_str());
134  env->PutInt("NoTlsOK", 1);
135  return false;
136  }
137 
138  return true;
139  }
static std::unique_ptr< XrdTlsContext > tlsContext
Definition: XrdClTls.cc:34
int emsg(int rc, char *msg)
static Log * GetLog()
Get default log.
static Env * GetEnv()
Get default client environment.
bool PutInt(const std::string &key, int value)
Definition: XrdClEnv.cc:110
bool GetInt(const std::string &key, int &value)
Definition: XrdClEnv.cc:89
Handle diagnostics.
Definition: XrdClLog.hh:101
void Error(uint64_t topic, const char *format,...)
Report an error.
Definition: XrdClLog.cc:231
static const char * ValPath(const char *path, mode_t allow, bool isdir)
const uint64_t TlsMsg

References emsg(), XrdCl::Log::Error(), XrdCl::DefaultEnv::GetEnv(), XrdCl::Env::GetInt(), XrdCl::DefaultEnv::GetLog(), XrdCl::Env::PutInt(), tlsContext, TlsMsg, and XrdOucUtils::ValPath().

Referenced by XrdCl::Tls::Tls(), and XrdTlsContext::Init().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ List()

ZipListImpl<false> XrdCl::List ( Ctx< ZipArchive zip)
inline

Factory for creating ZipStatImpl objects.

Definition at line 574 of file XrdClZipOperations.hh.

575  {
576  return ZipListImpl<false>( std::move( zip ) );
577  }

Referenced by XrdFrmXfrAgent::Process(), and XrdCmsCluster::Statt().

+ Here is the caller graph for this function:

◆ ListXAttr() [1/2]

ListXAttrImpl<false> XrdCl::ListXAttr ( Ctx< File file)
inline

Factory for creating ListXAttrImpl objects (as there is another ListXAttr in FileSystem there would be a clash of typenames).

Definition at line 1361 of file XrdClFileOperations.hh.

1362  {
1363  return ListXAttrImpl<false>( std::move( file ) );
1364  }

◆ ListXAttr() [2/2]

ListXAttrFsImpl<false> XrdCl::ListXAttr ( Ctx< FileSystem fs,
Arg< std::string >  path 
)
inline

Factory for creating ListXAttrFsImpl objects (as there is another ListXAttr in FileSystem there would be a clash of typenames).

Definition at line 1257 of file XrdClFileSystemOperations.hh.

1258  {
1259  return ListXAttrFsImpl<false>( std::move( fs ), std::move( path ) );
1260  }

◆ make_fwd()

template<typename T , typename... Args>
std::shared_ptr<FwdStorage<T> > XrdCl::make_fwd ( Args &&...  args)
inline

Definition at line 245 of file XrdClFwd.hh.

246  {
247  return std::make_shared<FwdStorage<T>>( std::forward<Args>( args )... );
248  }

◆ Open()

OpenImpl<false> XrdCl::Open ( Ctx< File file,
Arg< std::string >  url,
Arg< OpenFlags::Flags flags,
Arg< Access::Mode mode = Access::None,
uint16_t  timeout = 0 
)
inline

Factory for creating ReadImpl objects.

Definition at line 215 of file XrdClFileOperations.hh.

217  {
218  return OpenImpl<false>( std::move( file ), std::move( url ), std::move( flags ),
219  std::move( mode ) ).Timeout( timeout );
220  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by XrdCl::ActionExecutor::Execute(), and XrdCl::ZipArchive::OpenArchive().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ OpenArchive()

OpenArchiveImpl<false> XrdCl::OpenArchive ( Ctx< ZipArchive zip,
Arg< std::string >  fn,
Arg< OpenFlags::Flags flags,
uint16_t  timeout = 0 
)
inline

Factory for creating OpenArchiveImpl objects.

Definition at line 123 of file XrdClZipOperations.hh.

125  {
126  return OpenArchiveImpl<false>( std::move( zip ), std::move( fn ),
127  std::move( flags ) ).Timeout( timeout );
128  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by XrdEc::Reader::Open(), and XrdEc::StrmWriter::Open().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ OpenFile()

OpenFileImpl<false> XrdCl::OpenFile ( Ctx< ZipArchive zip,
Arg< std::string >  fn,
Arg< OpenFlags::Flags flags = OpenFlags::None,
Arg< uint64_t >  size = 0,
Arg< uint32_t >  crc32 = 0,
uint16_t  timeout = 0 
)
inline

Factory for creating OpenFileImpl objects.

Definition at line 184 of file XrdClZipOperations.hh.

187  {
188  return OpenFileImpl<false>( std::move( zip ), std::move( fn ), std::move( flags ),
189  std::move( size ), std::move( crc32 ) ).Timeout( timeout );
190  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

+ Here is the call graph for this function:

◆ Parallel() [1/2]

template<class Container >
ParallelOperation<false> XrdCl::Parallel ( Container &&  container)
inline

Factory function for creating parallel operation from a vector.

Definition at line 506 of file XrdClParallelOperation.hh.

507  {
508  return ParallelOperation<false>( container );
509  }

Referenced by XrdEc::Reader::Close(), DoRm(), DoStat(), XrdEc::Reader::Open(), XrdEc::StrmWriter::Open(), and Parallel().

+ Here is the caller graph for this function:

◆ Parallel() [2/2]

template<typename ... Operations>
ParallelOperation<false> XrdCl::Parallel ( Operations &&...  operations)
inline

Factory function for creating parallel operation from a given number of operations (we use && reference since due to reference collapsing this will fit both r- and l-value references)

Definition at line 569 of file XrdClParallelOperation.hh.

570  {
571  constexpr size_t size = sizeof...( operations );
572  std::vector<Pipeline> v;
573  v.reserve( size );
574  PipesToVec( v, operations... );
575  return Parallel( v );
576  }
ParallelOperation< false > Parallel(Operations &&... operations)
void PipesToVec(std::vector< Pipeline > &v, Pipeline &pipeline, Others &... others)

References Parallel(), and PipesToVec().

+ Here is the call graph for this function:

◆ ParseInput()

std::unordered_map<File*, action_list> XrdCl::ParseInput ( const std::string &  path,
double &  t0,
double &  t1,
std::unordered_map< File *, std::string > &  filenames,
std::unordered_map< File *, double > &  synchronicity,
std::unordered_map< File *, size_t > &  responseerrors,
const std::vector< std::string > &  option_regex 
)

Parse input file

Parameters
path: path to the input csv file

Definition at line 904 of file XrdClReplay.cc.

911 {
912  std::unordered_map<File*, action_list> result;
913  std::unique_ptr<std::ifstream> fin( path.empty() ? nullptr : new std::ifstream( path, std::ifstream::in ) );
914  std::istream &input = path.empty() ? std::cin : *fin;
915  std::string line;
916  std::unordered_map<uint64_t, File*> files;
917  std::unordered_map<uint64_t, double> last_stop;
918  std::unordered_map<uint64_t, double> overlaps;
919  std::unordered_map<uint64_t, double> overlaps_cnt;
920 
921  t0 = 10e99;
922  t1 = 0;
923  while (input.good())
924  {
925  std::getline(input, line);
926  if (line.empty())
927  continue;
928  std::vector<std::string> tokens = ToColumns( line );
929  if (tokens.size() == 6)
930  tokens.emplace_back();
931  if (tokens.size() != 7)
932  {
933  throw std::invalid_argument("Invalid input file format.");
934  }
935 
936  uint64_t id = std::stoull(tokens[0]); // file object ID
937  std::string action = tokens[1]; // action name (e.g. Open)
938  double start = std::stod(tokens[2]); // start time
939  std::string args = tokens[3]; // operation arguments
940  double stop = std::stod(tokens[4]); // stop time
941  std::string status = tokens[5]; // operation status
942  std::string resp = tokens[6]; // server response
943 
944  if (option_regex.size())
945  {
946  for (auto& v : option_regex)
947  {
948  std::vector<std::string> tokens;
949  Utils::splitString(tokens, v, ":=");
950  std::regex src(tokens[0]);
951  if (tokens.size() != 2)
952  {
953  std::cerr
954  << "Error: invalid regex for argument replacement - must be format like <oldstring>:=<newstring>"
955  << std::endl;
956  exit(EINVAL);
957  }
958  else
959  {
960  // write the results to an output iterator
961  args = std::regex_replace(args, src, tokens[1]);
962  }
963  }
964  }
965 
966  if (start < t0)
967  t0 = start;
968  if (stop > t1)
969  t1 = stop;
970 
971  if (!files.count(id))
972  {
973  files[id] = new File(false);
974  files[id]->SetProperty("BundledClose", "true");
975  filenames[files[id]] = args;
976  filenames[files[id]].erase(args.find(";"));
977  overlaps[id] = 0;
978  overlaps_cnt[id] = 0;
979  last_stop[id] = stop;
980  }
981  else
982  {
983  overlaps_cnt[id]++;
984  if (start > last_stop[id])
985  {
986  overlaps[id]++;
987  }
988  last_stop[id] = stop;
989  }
990 
991  last_stop[id] = stop;
992  double nominal_duration = stop - start;
993 
994  if (status != "[SUCCESS]")
995  {
996  responseerrors[files[id]]++;
997  }
998  else
999  {
1000  result[files[id]].emplace(
1001  start, ActionExecutor(*files[id], action, args, status, resp, nominal_duration));
1002  }
1003  }
1004 
1005  for (auto& it : overlaps)
1006  {
1007  // compute the synchronicity of requests
1008  synchronicity[files[it.first]] = 100.0 * (it.second / overlaps_cnt[it.first]);
1009  }
1010  return result;
1011 }
static unsigned long long int stoull(const std::string &s)
simple integer parsing, to be replaced by std::stoll when C++11 can be used
XrdOucString File
void getline(uchar *buff, int blen)
std::vector< std::string > ToColumns(const std::string &row)
Split a row into columns.
Definition: XrdClReplay.cc:826

References File, getline(), XrdCl::Utils::splitString(), stoull(), and ToColumns().

Referenced by main().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ PgRead()

PgReadImpl<false> XrdCl::PgRead ( Ctx< File file,
Arg< uint64_t >  offset,
Arg< uint32_t >  size,
Arg< void * >  buffer,
uint16_t  timeout = 0 
)
inline

Factory for creating PgReadImpl objects.

Definition at line 331 of file XrdClFileOperations.hh.

334  {
335  return PgReadImpl<false>( std::move( file ), std::move( offset ), std::move( size ),
336  std::move( buffer ) ).Timeout( timeout );
337  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by XrdCl::ActionExecutor::Execute().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ PgWrite() [1/2]

PgWriteImpl<false> XrdCl::PgWrite ( Ctx< File file,
Arg< uint64_t >  offset,
Arg< uint32_t >  size,
Arg< void * >  buffer,
Arg< std::vector< uint32_t >>  cksums,
uint16_t  timeout = 0 
)
inline

Factory for creating PgReadImpl objects.

Definition at line 420 of file XrdClFileOperations.hh.

424  {
425  return PgWriteImpl<false>( std::move( file ), std::move( offset ), std::move( size ),
426  std::move( buffer ), std::move( cksums ) ).Timeout( timeout );
427  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by XrdCl::ActionExecutor::Execute().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ PgWrite() [2/2]

PgWriteImpl<false> XrdCl::PgWrite ( Ctx< File file,
Arg< uint64_t >  offset,
Arg< uint32_t >  size,
Arg< void * >  buffer,
uint16_t  timeout = 0 
)
inline

Factory for creating PgReadImpl objects.

Definition at line 432 of file XrdClFileOperations.hh.

435  {
436  std::vector<uint32_t> cksums;
437  return PgWriteImpl<false>( std::move( file ), std::move( offset ), std::move( size ),
438  std::move( buffer ), std::move( cksums ) ).Timeout( timeout );
439  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

+ Here is the call graph for this function:

◆ PipesToVec() [1/4]

void XrdCl::PipesToVec ( std::vector< Pipeline > &  )
inline

Helper function for converting parameter pack into a vector.

Definition at line 514 of file XrdClParallelOperation.hh.

515  {
516  // base case
517  }

Referenced by Parallel(), and PipesToVec().

+ Here is the caller graph for this function:

◆ PipesToVec() [2/4]

template<typename ... Others>
void XrdCl::PipesToVec ( std::vector< Pipeline > &  v,
Operation< false > &  operation,
Others &...  others 
)
inline

Definition at line 539 of file XrdClParallelOperation.hh.

541  {
542  v.emplace_back( operation );
543  PipesToVec( v, others... );
544  }

References PipesToVec().

+ Here is the call graph for this function:

◆ PipesToVec() [3/4]

template<typename ... Others>
void XrdCl::PipesToVec ( std::vector< Pipeline > &  v,
Operation< true > &  operation,
Others &...  others 
)
inline

Definition at line 547 of file XrdClParallelOperation.hh.

549  {
550  v.emplace_back( operation );
551  PipesToVec( v, others... );
552  }

References PipesToVec().

+ Here is the call graph for this function:

◆ PipesToVec() [4/4]

template<typename ... Others>
void XrdCl::PipesToVec ( std::vector< Pipeline > &  v,
Pipeline pipeline,
Others &...  others 
)
inline

Definition at line 555 of file XrdClParallelOperation.hh.

557  {
558  v.emplace_back( std::move( pipeline ) );
559  PipesToVec( v, others... );
560  }

References PipesToVec().

+ Here is the call graph for this function:

◆ PropertyList::Get< std::string >() [1/2]

template<>
std::string XrdCl::PropertyList::Get< std::string > ( const std::string &  name) const
inline

Definition at line 201 of file XrdClPropertyList.hh.

202  {
203  PropertyMap::const_iterator it;
204  it = pProperties.find( name );
205  if( it == pProperties.end() )
206  return std::string();
207  return it->second;
208  }

◆ PropertyList::Get< std::string >() [2/2]

template<>
bool XrdCl::PropertyList::Get< std::string > ( const std::string &  name,
std::string &  item 
) const
inline

Definition at line 189 of file XrdClPropertyList.hh.

191  {
192  PropertyMap::const_iterator it;
193  it = pProperties.find( name );
194  if( it == pProperties.end() )
195  return false;
196  item = it->second;
197  return true;
198  }

◆ PropertyList::Get< std::vector< std::string > >()

template<>
bool XrdCl::PropertyList::Get< std::vector< std::string > > ( const std::string &  name,
std::vector< std::string > &  item 
) const
inline

Definition at line 301 of file XrdClPropertyList.hh.

304  {
305  std::string tmp;
306  item.clear();
307  for( int i = 0; HasProperty( name, i ); ++i )
308  {
309  if( !Get( name, i, tmp ) )
310  return false;
311  item.push_back( tmp );
312  }
313  return true;
314  }

◆ PropertyList::Set< std::vector< std::string > >()

template<>
void XrdCl::PropertyList::Set< std::vector< std::string > > ( const std::string &  name,
const std::vector< std::string > &  item 
)
inline

Definition at line 287 of file XrdClPropertyList.hh.

290  {
291  std::vector<std::string>::const_iterator it;
292  int i = 0;
293  for( it = item.begin(); it != item.end(); ++it, ++i )
294  Set( name, i, *it );
295  }

◆ RdWithRsp()

template<typename RSP >
ReadTrait<RSP>::RET XrdCl::RdWithRsp ( Ctx< File file,
Arg< uint64_t >  offset,
Arg< uint32_t >  size,
Arg< void * >  buffer,
uint16_t  timeout = 0 
)
inline

◆ RdWithRsp< ChunkInfo >()

template<>
ReadImpl<false> XrdCl::RdWithRsp< ChunkInfo > ( Ctx< File file,
Arg< uint64_t >  offset,
Arg< uint32_t >  size,
Arg< void * >  buffer,
uint16_t  timeout 
)
inline

Definition at line 349 of file XrdClFileOperations.hh.

355  {
356  return Read( std::move( file ), std::move( offset ), std::move( size ),
357  std::move( buffer ), timeout );
358  }
ReadImpl< false > Read(Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout=0)
Factory for creating ReadImpl objects.

◆ RdWithRsp< PageInfo >()

template<>
PgReadImpl<false> XrdCl::RdWithRsp< PageInfo > ( Ctx< File file,
Arg< uint64_t >  offset,
Arg< uint32_t >  size,
Arg< void * >  buffer,
uint16_t  timeout 
)
inline

Definition at line 349 of file XrdClFileOperations.hh.

363  {
364  return PgRead( std::move( file ), std::move( offset ), std::move( size ),
365  std::move( buffer ), timeout );
366  }
PgReadImpl< false > PgRead(Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout=0)
Factory for creating PgReadImpl objects.

◆ Read() [1/2]

ReadImpl<false> XrdCl::Read ( Ctx< File file,
Arg< uint64_t >  offset,
Arg< uint32_t >  size,
Arg< void * >  buffer,
uint16_t  timeout = 0 
)
inline

Factory for creating ReadImpl objects.

Definition at line 273 of file XrdClFileOperations.hh.

275  {
276  return ReadImpl<false>( std::move( file ), std::move( offset ), std::move( size ),
277  std::move( buffer ) ).Timeout( timeout );
278  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by XrdCl::ActionExecutor::Execute(), XrdCl::ZipArchive::OpenArchive(), and XrdCl::EcHandler::PgRead().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Read() [2/2]

ZipReadImpl<false> XrdCl::Read ( Ctx< ZipArchive zip,
Arg< uint64_t >  offset,
Arg< uint32_t >  size,
Arg< void * >  buffer,
uint16_t  timeout = 0 
)
inline

Factory for creating ArchiveReadImpl objects.

Definition at line 244 of file XrdClZipOperations.hh.

246  {
247  return ZipReadImpl<false>( std::move( zip ), std::move( offset ), std::move( size ),
248  std::move( buffer ) ).Timeout( timeout );
249  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

+ Here is the call graph for this function:

◆ ReadFrom()

ZipReadFromImpl<false> XrdCl::ReadFrom ( Ctx< ZipArchive zip,
Arg< std::string >  fn,
Arg< uint64_t >  offset,
Arg< uint32_t >  size,
Arg< void * >  buffer,
uint16_t  timeout = 0 
)
inline

Factory for creating ArchiveReadImpl objects.

Definition at line 302 of file XrdClZipOperations.hh.

305  {
306  return ZipReadFromImpl<false>( std::move( zip ), std::move( fn ), std::move( offset ),
307  std::move( size ), std::move( buffer ) ).Timeout( timeout );
308  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

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

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ ReadFromImpl()

template<typename RSP >
XRootDStatus XrdCl::ReadFromImpl ( ZipArchive me,
const std::string &  fn,
uint64_t  relativeOffset,
uint32_t  size,
void *  usrbuff,
ResponseHandler usrHandler,
uint16_t  timeout 
)

Definition at line 44 of file XrdClZipArchive.cc.

51  {
52  if( me.openstage != ZipArchive::Done || !me.archive.IsOpen() )
53  return XRootDStatus( stError, errInvalidOp );
54 
55  Log *log = DefaultEnv::GetLog();
56 
57  auto cditr = me.cdmap.find( fn );
58  if( cditr == me.cdmap.end() )
59  return XRootDStatus( stError, errNotFound,
60  errNotFound, "File not found." );
61 
62  CDFH *cdfh = me.cdvec[cditr->second].get();
63 
64  // check if the file is compressed, for now we only support uncompressed and inflate/deflate compression
65  if( cdfh->compressionMethod != 0 && cdfh->compressionMethod != Z_DEFLATED )
66  return XRootDStatus( stError, errNotSupported,
67  0, "The compression algorithm is not supported!" );
68 
69  // Now the problem is that at the beginning of our
70  // file there is the Local-file-header, which size
71  // is not known because of the variable size 'extra'
72  // field, so we need to know the offset of the next
73  // record and shift it by the file size.
74  // The next record is either the next LFH (next file)
75  // or the start of the Central-directory.
76  uint64_t cdOffset = me.zip64eocd ? me.zip64eocd->cdOffset : me.eocd->cdOffset;
77  uint64_t nextRecordOffset = ( cditr->second + 1 < me.cdvec.size() ) ?
78  CDFH::GetOffset( *me.cdvec[cditr->second + 1] ) : cdOffset;
79  uint64_t filesize = cdfh->compressedSize;
80  if( filesize == std::numeric_limits<uint32_t>::max() && cdfh->extra )
81  filesize = cdfh->extra->compressedSize;
82  uint16_t descsize = cdfh->HasDataDescriptor() ?
83  DataDescriptor::GetSize( cdfh->IsZIP64() ) : 0;
84  uint64_t fileoff = nextRecordOffset - filesize - descsize;
85  uint64_t offset = fileoff + relativeOffset;
86  uint64_t uncompressedSize = cdfh->uncompressedSize;
87  if( uncompressedSize == std::numeric_limits<uint32_t>::max() && cdfh->extra )
88  uncompressedSize = cdfh->extra->uncompressedSize;
89  uint64_t sizeTillEnd = relativeOffset > uncompressedSize ?
90  0 : uncompressedSize - relativeOffset;
91  if( size > sizeTillEnd ) size = sizeTillEnd;
92 
93  // if it is a compressed file use ZIP cache to read from the file
94  if( cdfh->compressionMethod == Z_DEFLATED )
95  {
96  log->Dump( ZipMsg, "[%p] Reading compressed data.", &me );
97  // check if respective ZIP cache exists
98  bool empty = me.zipcache.find( fn ) == me.zipcache.end();
99  // if the entry does not exist, it will be created using
100  // default constructor
101  ZipCache &cache = me.zipcache[fn];
102 
103  if( relativeOffset > uncompressedSize )
104  {
105  // we are reading past the end of file,
106  // we can serve the request right away!
107  RSP *r = new RSP( relativeOffset, 0, usrbuff );
108  AnyObject *rsp = new AnyObject();
109  rsp->Set( r );
110  usrHandler->HandleResponse( new XRootDStatus(), rsp );
111  return XRootDStatus();
112  }
113 
114  uint32_t sizereq = size;
115  if( relativeOffset + size > uncompressedSize )
116  sizereq = uncompressedSize - relativeOffset;
117  cache.QueueReq( relativeOffset, sizereq, usrbuff, usrHandler );
118 
119  // if we have the whole ZIP archive we can populate the cache
120  // straight away
121  if( empty && me.buffer)
122  {
123  auto begin = me.buffer.get() + fileoff;
124  auto end = begin + filesize ;
125  buffer_t buff( begin, end );
126  cache.QueueRsp( XRootDStatus(), 0, std::move( buff ) );
127  return XRootDStatus();
128  }
129 
130  // if we don't have the data we need to issue a remote read
131  if( !me.buffer )
132  {
133  if( relativeOffset > filesize ) return XRootDStatus(); // there's nothing to do,
134  // we already have all the data locally
135  uint32_t rdsize = size;
136  // check if this is the last read (we reached the end of
137  // file from user perspective)
138  if( relativeOffset + size >= uncompressedSize )
139  {
140  // if yes, make sure we readout all the compressed data
141  // Note: In a patological case the compressed size may
142  // be greater than the uncompressed size
143  rdsize = filesize > relativeOffset ?
144  filesize - relativeOffset :
145  0;
146  }
147  // make sure we are not reading past the end of
148  // compressed data
149  if( relativeOffset + size > filesize )
150  rdsize = filesize - relativeOffset;
151 
152 
153  // now read the data ...
154  auto rdbuff = std::make_shared<ZipCache::buffer_t>( rdsize );
155  Pipeline p = XrdCl::RdWithRsp<RSP>( me.archive, offset, rdbuff->size(), rdbuff->data() ) >>
156  [relativeOffset, rdbuff, &cache, &me]( XRootDStatus &st, RSP &rsp )
157  {
158  Log *log = DefaultEnv::GetLog();
159  log->Dump( ZipMsg, "[%p] Read %u bytes of remote data at offset %llu.",
160  &me, rsp.GetLength(), (unsigned long long) rsp.GetOffset() );
161  cache.QueueRsp( st, relativeOffset, std::move( *rdbuff ) );
162  };
163  Async( std::move( p ), timeout );
164  }
165 
166  return XRootDStatus();
167  }
168 
169  // check if we have the whole file in our local buffer
170  if( me.buffer || size == 0 )
171  {
172  if( size )
173  {
174  memcpy( usrbuff, me.buffer.get() + offset, size );
175  log->Dump( ZipMsg, "[%p] Serving read from local cache.", &me );
176  }
177 
178  if( usrHandler )
179  {
180  XRootDStatus *st = ZipArchive::make_status();
181  RSP *rsp = new RSP( relativeOffset, size, usrbuff );
182  ZipArchive::Schedule( usrHandler, st, rsp );
183  }
184  return XRootDStatus();
185  }
186 
187  Pipeline p = XrdCl::RdWithRsp<RSP>( me.archive, offset, size, usrbuff ) >>
188  [=, &me]( XRootDStatus &st, RSP &r )
189  {
190  log->Dump( ZipMsg, "[%p] Read %u bytes of remote data at "
191  "offset %llu.", &me, r.GetLength(), (unsigned long long) r.GetOffset() );
192  if( usrHandler )
193  {
194  XRootDStatus *status = ZipArchive::make_status( st );
195  RSP *rsp = nullptr;
196  if( st.IsOK() )
197  rsp = new RSP( relativeOffset, r.GetLength(), r.GetBuffer() );
198  usrHandler->HandleResponse( status, ZipArchive::PkgRsp( rsp ) );
199  }
200  };
201  Async( std::move( p ), timeout );
202  return XRootDStatus();
203  }
const uint16_t stError
An error occurred that could potentially be retried.
Definition: XrdClStatus.hh:32
std::future< XRootDStatus > Async(Pipeline pipeline, uint16_t timeout=0)
const uint16_t errNotFound
Definition: XrdClStatus.hh:100
const uint64_t ZipMsg
const uint16_t errInvalidOp
Definition: XrdClStatus.hh:51
const uint16_t errNotSupported
Definition: XrdClStatus.hh:62
XrdSysError Log
Definition: XrdConfig.cc:112
std::vector< char > buffer_t
Definition: XrdZipUtils.hh:56
uint32_t uncompressedSize
Definition: XrdZipCDFH.hh:336
std::unique_ptr< Extra > extra
Definition: XrdZipCDFH.hh:345
uint16_t compressionMethod
Definition: XrdZipCDFH.hh:332
bool HasDataDescriptor()
Definition: XrdZipCDFH.hh:324
uint32_t compressedSize
Definition: XrdZipCDFH.hh:335
bool IsZIP64() const
Definition: XrdZipCDFH.hh:316

◆ SetUpLogging()

void XrdCl::SetUpLogging ( Log logger)

Definition at line 15 of file XrdClHttpPlugInUtil.cc.

15  {
16  // Assert that there is no existing topic
17  std::call_once(logging_topic_init, [logger] {
18  if (logger) {
19  logger->SetTopicName(kLogXrdClHttp, "XrdClHttp");
20  }
21  });
22 }
static std::once_flag logging_topic_init
static const uint64_t kLogXrdClHttp

References kLogXrdClHttp, logging_topic_init, and XrdCl::Log::SetTopicName().

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

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ SetXAttr() [1/4]

SetXAttrImpl<false> XrdCl::SetXAttr ( Ctx< File file,
Arg< std::string >  name,
Arg< std::string >  value 
)
inline

Factory for creating SetXAttrImpl objects (as there is another SetXAttr in FileSystem there would be a clash of typenames).

Definition at line 1021 of file XrdClFileOperations.hh.

1022  {
1023  return SetXAttrImpl<false>( std::move( file ), std::move( name ), std::move( value ) );
1024  }

◆ SetXAttr() [2/4]

SetXAttrBulkImpl<false> XrdCl::SetXAttr ( Ctx< File file,
Arg< std::vector< xattr_t >>  attrs 
)
inline

Factory for creating SetXAttrBulkImpl objects (as there is another SetXAttr in FileSystem there would be a clash of typenames).

Definition at line 1077 of file XrdClFileOperations.hh.

1078  {
1079  return SetXAttrBulkImpl<false>( std::move( file ), std::move( attrs ) );
1080  }

◆ SetXAttr() [3/4]

SetXAttrFsImpl<false> XrdCl::SetXAttr ( Ctx< FileSystem fs,
Arg< std::string >  path,
Arg< std::string >  name,
Arg< std::string >  value 
)
inline

Factory for creating SetXAttrFsImpl objects (as there is another SetXAttr in File there would be a clash of typenames).

Definition at line 904 of file XrdClFileSystemOperations.hh.

906  {
907  return SetXAttrFsImpl<false>( std::move( fs ), std::move( path ), std::move( name ),
908  std::move( value ) );
909  }

◆ SetXAttr() [4/4]

SetXAttrFsBulkImpl<false> XrdCl::SetXAttr ( Ctx< FileSystem fs,
Arg< std::string >  path,
Arg< std::vector< xattr_t >>  attrs 
)
inline

Factory for creating SetXAttrFsBulkImpl objects (as there is another SetXAttr in FileSystem there would be a clash of typenames).

Definition at line 961 of file XrdClFileSystemOperations.hh.

963  {
964  return SetXAttrFsBulkImpl<false>( std::move( fs ), std::move( path ), std::move( attrs ) );
965  }

◆ Stat() [1/3]

StatImpl<false> XrdCl::Stat ( Ctx< File file,
Arg< bool >  force,
uint16_t  timeout = 0 
)
inline

Factory for creating StatImpl objects (as there is another Stat in FileSystem there would be a clash of typenames).

Definition at line 535 of file XrdClFileOperations.hh.

536  {
537  return StatImpl<false>( std::move( file ), std::move( force ) ).Timeout( timeout );
538  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by DoStat(), XrdCl::ActionExecutor::Execute(), and XrdCl::ZipArchive::Stat().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Stat() [2/3]

StatFsImpl<false> XrdCl::Stat ( Ctx< FileSystem fs,
Arg< std::string >  path 
)
inline

Definition at line 608 of file XrdClFileSystemOperations.hh.

609  {
610  return StatFsImpl<false>( std::move( fs ), std::move( path ) );
611  }

◆ Stat() [3/3]

ZipStatImpl<false> XrdCl::Stat ( Ctx< ZipArchive zip)
inline

Factory for creating ZipStatImpl objects.

Definition at line 523 of file XrdClZipOperations.hh.

524  {
525  return ZipStatImpl<false>( std::move( zip ) );
526  }

◆ Sync()

SyncImpl<false> XrdCl::Sync ( Ctx< File file,
uint16_t  timeout = 0 
)
inline

Factory for creating SyncImpl objects.

Definition at line 639 of file XrdClFileOperations.hh.

640  {
641  return SyncImpl<false>( std::move( file ) ).Timeout( timeout );
642  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by XrdCl::ActionExecutor::Execute(), and XrdCmsProtocol::Process().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ To()

template<typename T >
T& XrdCl::To ( AnyObject any)
inline

Helper function for extracting an object from AnyObject

Parameters
any: an instance of AnyObject
Returns
: the underlying value of type T

Definition at line 151 of file XrdClAnyObject.hh.

152  {
153  T* object;
154  any.Get( object );
155  return *object;
156  }

References XrdCl::AnyObject::Get().

+ Here is the call graph for this function:

◆ to_lower()

static std::string XrdCl::to_lower ( std::string  str)
inlinestatic

Definition at line 116 of file XrdClConstants.hh.

117  {
118  std::transform( str.begin(), str.end(), str.begin(), ::tolower );
119  return str;
120  }

◆ ToColumns()

std::vector<std::string> XrdCl::ToColumns ( const std::string &  row)

Split a row into columns.

loop over all the columns in the row

Definition at line 826 of file XrdClReplay.cc.

827 {
828  std::vector<std::string> columns;
829  size_t quotecnt = 0;
830  size_t pos = 0;
831  //----------------------------------------------------------------------------
833  //----------------------------------------------------------------------------
834  while( pos != std::string::npos && pos < row.size() )
835  {
836  if( row[pos] == '"' ) // we are handling a quoted column
837  {
838  if( quotecnt > 0 ) // this is a closing quote
839  {
840  if( pos + 1 < row.size() && row[pos + 1] != ',' ) // if it is not the last character in the row it should be followed by a comma
841  throw std::runtime_error( "Parsing error: missing comma" );
842  --quotecnt; // strip the quote
843  ++pos; // move to the comma or end of row
844  continue;
845  }
846  else // this is a opening quote
847  {
848  ++quotecnt;
849  auto b = std::next( row.begin(), pos + 1 ); // iterator to the beginning of our column
850  size_t posend = row.find( "\",", pos + 1 ); // position of the cursor to the end of our column
851  if( posend == std::string::npos && row[row.size() - 1] == '"' )
852  posend = row.size() - 1;
853  else if( posend == std::string::npos )
854  throw std::runtime_error( "Parsing error: missing closing quote" );
855  auto e = std::next( row.begin(), posend ); // iterator to the end of our column
856  columns.emplace_back( b, e ); // add the column to the result
857  pos = posend; // move to the next column
858  continue;
859  }
860  }
861  else if( row[pos] == ',' ) // we are handling a column separator
862  {
863  if( pos + 1 < row.size() && row[pos + 1] == '"' ) // check if the column is quoted
864  {
865  ++pos; // if yes we will handle this with the logic reserved for quoted columns
866  continue;
867  }
868  auto b = std::next( row.begin(), pos + 1 ); // iterator to the beginning of our column
869  size_t posend = row.find( ',', pos + 1 ); // position of the cursor to the end of our column
870  if( posend == std::string::npos )
871  posend = row.size();
872  auto e = std::next( row.begin(), posend ); // iterator to the end of our column
873  columns.emplace_back( b, e ); // add the column to the result
874  pos = posend; // move to the next column
875  continue;
876  }
877  else if( pos == 0 ) // we are handling the 1st column if not quoted
878  {
879  size_t posend = row.find( ',', pos + 1 ); // position of the cursor to the end of our column
880  if( posend == std::string::npos )
881  posend = row.size();
882  auto end = std::next( row.begin(), posend ); // iterator to the end of our column
883  columns.emplace_back( row.begin(), end ); // add the column to the result
884  pos = posend; // move to the next column
885  continue;
886  }
887  else
888  {
889  throw std::runtime_error( "Parsing error: invalid input file." );
890  }
891  }
892  return columns;
893 }

Referenced by ParseInput().

+ Here is the caller graph for this function:

◆ Truncate() [1/2]

TruncateImpl<false> XrdCl::Truncate ( Ctx< File file,
Arg< uint64_t >  size,
uint16_t  timeout 
)
inline

Factory for creating TruncateImpl objects (as there is another Stat in FileSystem there would be a clash of typenames).

Definition at line 692 of file XrdClFileOperations.hh.

693  {
694  return TruncateImpl<false>( std::move( file ), std::move( size ) ).Timeout( timeout );
695  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by XrdCl::ActionExecutor::Execute().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Truncate() [2/2]

TruncateFsImpl<false> XrdCl::Truncate ( Ctx< FileSystem fs,
Arg< std::string >  path,
Arg< uint64_t >  size 
)
inline

Definition at line 329 of file XrdClFileSystemOperations.hh.

330  {
331  return TruncateFsImpl<false>( std::move( fs ), std::move( path ), std::move( size ) );
332  }

◆ tuple_call_impl()

template<typename FUNC , typename TUPL , int ... INDICES>
static auto XrdCl::tuple_call_impl ( FUNC &  func,
TUPL &  args,
sequence< INDICES... >   
) -> decltype( func( std::move( std::get<INDICES>( args ) )... ) )
inlinestatic

Definition at line 49 of file XrdClApply.hh.

51  {
52  return func( std::move( std::get<INDICES>( args ) )... );
53  }

◆ VectorRead() [1/2]

VectorReadImpl<false> XrdCl::VectorRead ( Ctx< File file,
Arg< ChunkList chunks,
Arg< void * >  buffer,
uint16_t  timeout = 0 
)
inline

Factory for creating VectorReadImpl objects.

Definition at line 747 of file XrdClFileOperations.hh.

749  {
750  return VectorReadImpl<false>( std::move( file ), std::move( chunks ), std::move( buffer ) ).Timeout( timeout );
751  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by XrdCl::ActionExecutor::Execute(), and XrdEc::Reader::VectorRead().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ VectorRead() [2/2]

VectorReadImpl<false> XrdCl::VectorRead ( Ctx< File file,
Arg< ChunkList chunks,
uint16_t  timeout = 0 
)
inline

Definition at line 753 of file XrdClFileOperations.hh.

755  {
756  return VectorReadImpl<false>( std::move( file ), std::move( chunks ), nullptr ).Timeout( timeout );
757  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

+ Here is the call graph for this function:

◆ VectorWrite()

VectorWriteImpl<false> XrdCl::VectorWrite ( Ctx< File file,
Arg< ChunkList chunks,
uint16_t  timeout = 0 
)
inline

Factory for creating VectorWriteImpl objects.

Definition at line 807 of file XrdClFileOperations.hh.

809  {
810  return VectorWriteImpl<false>( std::move( file ), std::move( chunks ) ).Timeout( timeout );
811  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by XrdCl::ZipArchive::CloseArchive(), and XrdCl::ActionExecutor::Execute().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ WaitFor()

XRootDStatus XrdCl::WaitFor ( Pipeline  pipeline,
uint16_t  timeout = 0 
)
inline

Helper function, schedules execution of given pipeline and waits for the status

Parameters
pipeline: the pipeline to be executed
timeout: the pipeline timeout
Returns
: status of the operation

Definition at line 537 of file XrdClOperations.hh.

538  {
539  return Async( std::move( pipeline ), timeout ).get();
540  }

References Async().

Referenced by DoRm(), and XrdCl::ActionExecutor::Execute().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Write() [1/2]

WriteImpl<false> XrdCl::Write ( Ctx< File file,
Arg< uint64_t >  offset,
Arg< uint32_t >  size,
Arg< const void * >  buffer,
uint16_t  timeout = 0 
)
inline

Factory for creating WriteImpl objects.

Definition at line 591 of file XrdClFileOperations.hh.

593  {
594  return WriteImpl<false>( std::move( file ), std::move( offset ), std::move( size ),
595  std::move( buffer ) ).Timeout( timeout );
596  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

Referenced by XrdCl::ZipArchive::CloseArchive(), XrdCl::ActionExecutor::Execute(), and XrdCl::EcHandler::PgWrite().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Write() [2/2]

ZipWriteImpl<false> XrdCl::Write ( Ctx< ZipArchive zip,
Arg< uint32_t >  size,
Arg< const void * >  buffer,
uint16_t  timeout = 0 
)
inline

Factory for creating ArchiveReadImpl objects.

Definition at line 361 of file XrdClZipOperations.hh.

363  {
364  return ZipWriteImpl<false>( std::move( zip ), std::move( size ),
365  std::move( buffer ) ).Timeout( timeout );
366  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

+ Here is the call graph for this function:

◆ WriteV()

WriteVImpl<false> XrdCl::WriteV ( Ctx< File file,
Arg< uint64_t >  offset,
Arg< std::vector< iovec >>  iov,
uint16_t  timeout = 0 
)
inline

Factory for creating WriteVImpl objects.

Definition at line 872 of file XrdClFileOperations.hh.

874  {
875  return WriteVImpl<false>( std::move( file ), std::move( offset ),
876  std::move( iov ) ).Timeout( timeout );
877  }

References XrdCl::ConcreteOperation< Derived, HasHndl, HdlrFactory, Args >::Timeout().

+ Here is the call graph for this function:

Variable Documentation

◆ AppMsg

◆ AsyncSockMsg

◆ DefaultAioSignal

const int XrdCl::DefaultAioSignal = 0

Definition at line 84 of file XrdClConstants.hh.

◆ DefaultClConfDir

const char* const XrdCl::DefaultClConfDir = ""

Definition at line 111 of file XrdClConstants.hh.

◆ DefaultClConfFile

const char* const XrdCl::DefaultClConfFile = ""

Definition at line 112 of file XrdClConstants.hh.

◆ DefaultClientMonitor

const char* const XrdCl::DefaultClientMonitor = ""

Definition at line 102 of file XrdClConstants.hh.

Referenced by XrdCl::DefaultEnv::GetMonitor().

◆ DefaultClientMonitorParam

const char* const XrdCl::DefaultClientMonitorParam = ""

Definition at line 103 of file XrdClConstants.hh.

Referenced by XrdCl::DefaultEnv::GetMonitor().

◆ DefaultConnectionRetry

const int XrdCl::DefaultConnectionRetry = 5

Definition at line 53 of file XrdClConstants.hh.

Referenced by XrdCl::Stream::Stream().

◆ DefaultConnectionWindow

const int XrdCl::DefaultConnectionWindow = 120

Definition at line 52 of file XrdClConstants.hh.

Referenced by XrdCl::Stream::Stream().

◆ DefaultCPChunkSize

const int XrdCl::DefaultCPChunkSize = 8388608

◆ DefaultCPInitTimeout

const int XrdCl::DefaultCPInitTimeout = 600

Definition at line 65 of file XrdClConstants.hh.

Referenced by XrdCl::CopyProcess::AddJob().

◆ DefaultCPParallelChunks

const int XrdCl::DefaultCPParallelChunks = 4

Definition at line 62 of file XrdClConstants.hh.

Referenced by XrdCl::CopyProcess::AddJob(), and main().

◆ DefaultCpRetry

const int XrdCl::DefaultCpRetry = 0

Definition at line 97 of file XrdClConstants.hh.

◆ DefaultCpRetryPolicy

const char* const XrdCl::DefaultCpRetryPolicy = "force"

Definition at line 114 of file XrdClConstants.hh.

◆ DefaultCpTarget

const char* const XrdCl::DefaultCpTarget = ""

Definition at line 113 of file XrdClConstants.hh.

◆ DefaultCPTimeout

const int XrdCl::DefaultCPTimeout = 0

Definition at line 67 of file XrdClConstants.hh.

Referenced by XrdCl::CopyProcess::AddJob().

◆ DefaultCPTPCTimeout

const int XrdCl::DefaultCPTPCTimeout = 1800

Definition at line 66 of file XrdClConstants.hh.

Referenced by XrdCl::CopyProcess::AddJob().

◆ DefaultCpUsePgWrtRd

const int XrdCl::DefaultCpUsePgWrtRd = 1

Definition at line 98 of file XrdClConstants.hh.

◆ DefaultDataServerTTL

const int XrdCl::DefaultDataServerTTL = 300

Definition at line 63 of file XrdClConstants.hh.

Referenced by XrdCl::XRootDTransport::IsStreamTTLElapsed().

◆ DefaultGlfnRedirector

const char* const XrdCl::DefaultGlfnRedirector = ""

Definition at line 109 of file XrdClConstants.hh.

◆ DefaultIPNoShuffle

const int XrdCl::DefaultIPNoShuffle = 0

Definition at line 94 of file XrdClConstants.hh.

Referenced by XrdCl::Utils::GetHostAddresses().

◆ DefaultLoadBalancerTTL

const int XrdCl::DefaultLoadBalancerTTL = 1200

Definition at line 64 of file XrdClConstants.hh.

Referenced by XrdCl::XRootDTransport::IsStreamTTLElapsed().

◆ DefaultLocalMetalinkFile

const int XrdCl::DefaultLocalMetalinkFile = 0

Definition at line 75 of file XrdClConstants.hh.

◆ DefaultMaxMetalinkWait

const int XrdCl::DefaultMaxMetalinkWait = 60

Definition at line 86 of file XrdClConstants.hh.

Referenced by XrdCl::XRootDMsgHandler::Process().

◆ DefaultMetalinkProcessing

const int XrdCl::DefaultMetalinkProcessing = 1

Definition at line 74 of file XrdClConstants.hh.

Referenced by XrdCl::URL::IsMetalink().

◆ DefaultMultiProtocol

const int XrdCl::DefaultMultiProtocol = 0

Definition at line 72 of file XrdClConstants.hh.

◆ DefaultNetworkStack

const char* const XrdCl::DefaultNetworkStack = "IPAuto"

Definition at line 101 of file XrdClConstants.hh.

Referenced by XrdCl::Stream::Stream().

◆ DefaultNoDelay

const int XrdCl::DefaultNoDelay = 1

Definition at line 82 of file XrdClConstants.hh.

Referenced by XrdCl::Socket::Initialize().

◆ DefaultNotAuthorizedRetryLimit

const int XrdCl::DefaultNotAuthorizedRetryLimit = 3

Definition at line 88 of file XrdClConstants.hh.

◆ DefaultNoTlsOK

const int XrdCl::DefaultNoTlsOK = 0

Definition at line 90 of file XrdClConstants.hh.

Referenced by XrdCl::XRootDTransport::NeedEncryption().

◆ DefaultOpenRecovery

const char* const XrdCl::DefaultOpenRecovery = "true"

Definition at line 108 of file XrdClConstants.hh.

◆ DefaultParallelEvtLoop

const int XrdCl::DefaultParallelEvtLoop = 10

Definition at line 73 of file XrdClConstants.hh.

◆ DefaultPlugIn

const char* const XrdCl::DefaultPlugIn = ""

Definition at line 105 of file XrdClConstants.hh.

Referenced by XrdCl::PlugInManager::ProcessEnvironmentSettings().

◆ DefaultPlugInConfDir

const char* const XrdCl::DefaultPlugInConfDir = ""

Definition at line 104 of file XrdClConstants.hh.

Referenced by XrdCl::PlugInManager::ProcessEnvironmentSettings().

◆ DefaultPollerPreference

const char* const XrdCl::DefaultPollerPreference = "built-in"

Definition at line 100 of file XrdClConstants.hh.

Referenced by XrdCl::PostMaster::Initialize().

◆ DefaultPreferIPv4

const int XrdCl::DefaultPreferIPv4 = 0

Definition at line 85 of file XrdClConstants.hh.

Referenced by XrdCl::Utils::GetHostAddresses().

◆ DefaultPreserveLocateTried

const int XrdCl::DefaultPreserveLocateTried = 1

Definition at line 87 of file XrdClConstants.hh.

Referenced by XrdCl::MessageUtils::RewriteCGIAndPath().

◆ DefaultPreserveXAttrs

const int XrdCl::DefaultPreserveXAttrs = 0

Definition at line 89 of file XrdClConstants.hh.

Referenced by main().

◆ DefaultReadRecovery

const char* const XrdCl::DefaultReadRecovery = "true"

Definition at line 106 of file XrdClConstants.hh.

◆ DefaultRedirectLimit

const int XrdCl::DefaultRedirectLimit = 16

Definition at line 59 of file XrdClConstants.hh.

Referenced by XrdCl::MessageUtils::ProcessSendParams().

◆ DefaultRequestTimeout

const int XrdCl::DefaultRequestTimeout = 1800

◆ DefaultRetryWrtAtLBLimit

const int XrdCl::DefaultRetryWrtAtLBLimit = 3

Definition at line 96 of file XrdClConstants.hh.

◆ DefaultRunForkHandler

const int XrdCl::DefaultRunForkHandler = 1

Definition at line 58 of file XrdClConstants.hh.

Referenced by child(), parent(), and prepare().

◆ DefaultStreamErrorWindow

const int XrdCl::DefaultStreamErrorWindow = 1800

Definition at line 57 of file XrdClConstants.hh.

Referenced by XrdCl::Stream::Stream().

◆ DefaultStreamTimeout

const int XrdCl::DefaultStreamTimeout = 60

Definition at line 55 of file XrdClConstants.hh.

Referenced by XrdCl::XRootDTransport::IsStreamBroken().

◆ DefaultSubStreamsPerChannel

const int XrdCl::DefaultSubStreamsPerChannel = 1

Definition at line 51 of file XrdClConstants.hh.

Referenced by XrdCl::XRootDTransport::InitializeChannel().

◆ DefaultTCPKeepAlive

const int XrdCl::DefaultTCPKeepAlive = 0

Definition at line 68 of file XrdClConstants.hh.

Referenced by XrdCl::AsyncSocketHandler::Connect().

◆ DefaultTCPKeepAliveInterval

const int XrdCl::DefaultTCPKeepAliveInterval = 75

Definition at line 70 of file XrdClConstants.hh.

Referenced by XrdCl::AsyncSocketHandler::Connect().

◆ DefaultTCPKeepAliveProbes

const int XrdCl::DefaultTCPKeepAliveProbes = 9

Definition at line 71 of file XrdClConstants.hh.

Referenced by XrdCl::AsyncSocketHandler::Connect().

◆ DefaultTCPKeepAliveTime

const int XrdCl::DefaultTCPKeepAliveTime = 7200

Definition at line 69 of file XrdClConstants.hh.

Referenced by XrdCl::AsyncSocketHandler::Connect().

◆ DefaultTimeoutResolution

const int XrdCl::DefaultTimeoutResolution = 15

◆ DefaultTlsDbgLvl

const char* const XrdCl::DefaultTlsDbgLvl = "OFF"

Definition at line 110 of file XrdClConstants.hh.

◆ DefaultTlsMetalink

const int XrdCl::DefaultTlsMetalink = 0

Definition at line 92 of file XrdClConstants.hh.

◆ DefaultTlsNoData

const int XrdCl::DefaultTlsNoData = 0

Definition at line 91 of file XrdClConstants.hh.

Referenced by XrdCl::XRootDTransport::SubStreamNumber().

◆ DefaultWantTlsOnNoPgrw

const int XrdCl::DefaultWantTlsOnNoPgrw = 0

Definition at line 95 of file XrdClConstants.hh.

◆ DefaultWorkerThreads

const int XrdCl::DefaultWorkerThreads = 3

Definition at line 60 of file XrdClConstants.hh.

Referenced by XrdCl::PostMasterImpl::PostMasterImpl().

◆ DefaultWriteRecovery

const char* const XrdCl::DefaultWriteRecovery = "true"

Definition at line 107 of file XrdClConstants.hh.

◆ DefaultXCpBlockSize

const int XrdCl::DefaultXCpBlockSize = 134217728

Definition at line 77 of file XrdClConstants.hh.

Referenced by XrdCl::CopyProcess::AddJob(), and main().

◆ DefaultXRateThreshold

const int XrdCl::DefaultXRateThreshold = 0

Definition at line 76 of file XrdClConstants.hh.

Referenced by XrdCl::CopyProcess::AddJob().

◆ DefaultZipMtlnCksum

const int XrdCl::DefaultZipMtlnCksum = 0

Definition at line 93 of file XrdClConstants.hh.

Referenced by XrdCl::Utils::InferChecksumType().

◆ errAuthFailed

const uint16_t XrdCl::errAuthFailed = 204

Definition at line 88 of file XrdClStatus.hh.

◆ errCheckSumError

◆ errConfig

const uint16_t XrdCl::errConfig = 6

System misconfigured.

Definition at line 55 of file XrdClStatus.hh.

Referenced by XrdCl::Utils::ProcessConfig().

◆ errConnectionError

const uint16_t XrdCl::errConnectionError = 108

◆ errCorruptedHeader

◆ errDataError

◆ errErrorResponse

◆ errFcntl

const uint16_t XrdCl::errFcntl = 4

failed manipulate file descriptor

Definition at line 53 of file XrdClStatus.hh.

Referenced by XrdCl::Socket::Initialize().

◆ errHandShakeFailed

const uint16_t XrdCl::errHandShakeFailed = 202

Definition at line 86 of file XrdClStatus.hh.

◆ errInProgress

const uint16_t XrdCl::errInProgress = 10

Definition at line 59 of file XrdClStatus.hh.

Referenced by XrdCl::FileStateHandler::Close(), and XrdCl::FileStateHandler::Open().

◆ errInternal

◆ errInvalidAddr

const uint16_t XrdCl::errInvalidAddr = 101

Definition at line 71 of file XrdClStatus.hh.

Referenced by DoCat(), DoTail(), DoXAttr(), and XrdCl::Utils::GetHostAddresses().

◆ errInvalidArgs

◆ errInvalidMessage

◆ errInvalidOp

const uint16_t XrdCl::errInvalidOp = 3

The operation cannot be performed in the given circumstances

Definition at line 51 of file XrdClStatus.hh.

Referenced by XrdCl::ZipArchive::AppendFile(), XrdCl::FileStateHandler::Checkpoint(), XrdCl::FileStateHandler::ChkptWrt(), XrdCl::FileStateHandler::ChkptWrtV(), XrdCl::HttpFilePlugIn::Close(), XrdCl::FileStateHandler::Close(), XrdCl::ZipArchive::CloseFile(), XrdCl::Socket::Connect(), XrdCl::Socket::ConnectToAddress(), XrdCl::FileStateHandler::DelXAttr(), XrdCl::FileStateHandler::Fcntl(), XrdCl::PostMaster::ForceDisconnect(), XrdCl::PostMaster::ForceReconnect(), XrdCl::ZipArchive::GetCRC32(), XrdCl::Socket::GetFlags(), XrdCl::XRootDTransport::GetMore(), XrdCl::ZipArchive::GetOffset(), XrdCl::XRootDTransport::GetSignature(), XrdCl::Socket::GetSockOpt(), XrdCl::FileStateHandler::GetXAttr(), XrdCl::Socket::Initialize(), XrdCl::ZipArchive::List(), XrdCl::FileStateHandler::ListXAttr(), main(), xrdcl_proxy::ProxyPrefixFile::Open(), XrdCl::HttpFilePlugIn::Open(), XrdCl::FileStateHandler::Open(), XrdCl::ZipArchive::OpenArchive(), XrdCl::ZipArchive::OpenFile(), XrdCl::ZipArchive::PgRead(), XrdCl::FileStateHandler::PgReadImpl(), XrdCl::FileStateHandler::PgWriteImpl(), XrdCl::Socket::Poll(), XrdCl::PostMaster::QueryTransport(), XrdEc::block_t::read(), XrdCl::FileStateHandler::Read(), XrdCl::HttpFilePlugIn::Read(), XrdCl::ZipArchive::Read(), XrdCl::Socket::ReadRaw(), XrdCl::FileStateHandler::ReadV(), XrdCl::PostMaster::Redirect(), XrdCl::Socket::SetFlags(), XrdCl::Socket::SetSockOpt(), XrdCl::FileStateHandler::SetXAttr(), XrdCl::EcHandler::Stat(), XrdCl::HttpFilePlugIn::Stat(), XrdCl::ZipArchive::Stat(), XrdCl::FileStateHandler::Stat(), XrdCl::FileStateHandler::Sync(), XrdCl::Socket::TlsHandShake(), XrdCl::FileStateHandler::Truncate(), XrdCl::FileStateHandler::TryOtherServer(), XrdCl::ZipArchive::UpdateMetadata(), XrdCl::HttpFilePlugIn::VectorRead(), XrdCl::FileStateHandler::VectorRead(), XrdCl::FileStateHandler::VectorWrite(), XrdCl::FileStateHandler::Visa(), XrdCl::FileStateHandler::Write(), XrdCl::ZipArchive::Write(), XrdCl::HttpFilePlugIn::Write(), XrdCl::Socket::WriteRaw(), and XrdCl::FileStateHandler::WriteV().

◆ errInvalidRedirectURL

const uint16_t XrdCl::errInvalidRedirectURL = 302

Definition at line 98 of file XrdClStatus.hh.

Referenced by XrdCl::XRootDMsgHandler::Process().

◆ errInvalidResponse

◆ errInvalidSession

const uint16_t XrdCl::errInvalidSession = 109

Definition at line 79 of file XrdClStatus.hh.

Referenced by XrdCl::FileStateHandler::Close(), and XrdCl::Stream::Send().

◆ errLocalError

◆ errLoginFailed

const uint16_t XrdCl::errLoginFailed = 203

Definition at line 87 of file XrdClStatus.hh.

◆ errNoMoreFreeSIDs

const uint16_t XrdCl::errNoMoreFreeSIDs = 301

Definition at line 97 of file XrdClStatus.hh.

Referenced by XrdCl::SIDManager::AllocateSID().

◆ errNoMoreReplicas

const uint16_t XrdCl::errNoMoreReplicas = 16

No more replicas to try.

Definition at line 65 of file XrdClStatus.hh.

Referenced by XrdCl::XCpCtx::GetChunk().

◆ errNone

const uint16_t XrdCl::errNone = 0

No error.

Definition at line 48 of file XrdClStatus.hh.

◆ errNotFound

◆ errNotImplemented

◆ errNotSupported

◆ errOperationExpired

◆ errOperationInterrupted

const uint16_t XrdCl::errOperationInterrupted = 207

Definition at line 91 of file XrdClStatus.hh.

Referenced by XrdCl::Channel::ForceDisconnect(), and XrdCl::ClassicCopyJob::Run().

◆ errOSError

const uint16_t XrdCl::errOSError = 12

◆ errPipelineFailed

const uint16_t XrdCl::errPipelineFailed = 17

Pipeline failed and operation couldn't be executed.

Definition at line 66 of file XrdClStatus.hh.

Referenced by XrdCl::FutureWrapperBase< Response >::~FutureWrapperBase().

◆ errPoll

const uint16_t XrdCl::errPoll = 5

error while polling descriptors

Definition at line 54 of file XrdClStatus.hh.

Referenced by XrdCl::Socket::Poll().

◆ errPollerError

◆ errQueryNotSupported

const uint16_t XrdCl::errQueryNotSupported = 205

Definition at line 89 of file XrdClStatus.hh.

Referenced by XrdCl::Stream::Query(), and XrdCl::XRootDTransport::Query().

◆ errRedirect

const uint16_t XrdCl::errRedirect = 401

◆ errRedirectLimit

const uint16_t XrdCl::errRedirectLimit = 306

Definition at line 102 of file XrdClStatus.hh.

Referenced by XrdCl::XRootDMsgHandler::Process().

◆ errResponseNegative

const uint16_t XrdCl::errResponseNegative = 500

Query response was negative.

Definition at line 109 of file XrdClStatus.hh.

Referenced by ProcessStatQuery().

◆ errRetry

const uint16_t XrdCl::errRetry = 1

Try again for whatever reason.

Definition at line 49 of file XrdClStatus.hh.

Referenced by XrdCl::ClassicCopyJob::Run().

◆ errSocketDisconnected

const uint16_t XrdCl::errSocketDisconnected = 104

◆ errSocketError

◆ errSocketOptError

◆ errSocketTimeout

◆ errStreamDisconnect

const uint16_t XrdCl::errStreamDisconnect = 107

Definition at line 77 of file XrdClStatus.hh.

◆ errThresholdExceeded

const uint16_t XrdCl::errThresholdExceeded = 208

Definition at line 92 of file XrdClStatus.hh.

Referenced by XrdCl::ClassicCopyJob::Run().

◆ errTlsError

const uint16_t XrdCl::errTlsError = 110

Definition at line 80 of file XrdClStatus.hh.

Referenced by XrdCl::Socket::TlsHandShake().

◆ errUninitialized

const uint16_t XrdCl::errUninitialized = 11

◆ errUnknown

const uint16_t XrdCl::errUnknown = 2

Unknown error.

Definition at line 50 of file XrdClStatus.hh.

Referenced by Posix::PReadVec().

◆ errUnknownCommand

const uint16_t XrdCl::errUnknownCommand = 8

Definition at line 57 of file XrdClStatus.hh.

Referenced by XrdCl::FSExecutor::Execute().

◆ ExDbgMsg

◆ FileMsg

const uint64_t XrdCl::FileMsg = 0x0000000000000004ULL

Definition at line 34 of file XrdClConstants.hh.

Referenced by XrdCl::FileSystem::FileSystem(), XrdCl::FileStateHandler::AfterForkChild(), XrdCl::FileStateHandler::Checkpoint(), XrdCl::FileStateHandler::ChkptWrt(), XrdCl::FileStateHandler::ChkptWrtV(), XrdCl::LocalFileHandler::Close(), XrdCl::FileStateHandler::Close(), XrdCl::FileStateHandler::DelXAttr(), XrdCl::FileStateHandler::Fcntl(), XrdCl::FileStateHandler::GetXAttr(), XrdCl::FileStateHandler::ListXAttr(), XrdCl::FileStateHandler::OnClose(), XrdCl::FileStateHandler::OnOpen(), XrdCl::FileStateHandler::OnStateError(), XrdCl::FileStateHandler::OnStateResponse(), XrdCl::File::Open(), XrdCl::FileStateHandler::Open(), XrdCl::FileStateHandler::PgRead(), XrdCl::FileStateHandler::PgReadImpl(), XrdCl::FileStateHandler::PgWrite(), XrdCl::FileStateHandler::PgWriteImpl(), XrdCl::FileStateHandler::Read(), XrdCl::LocalFileHandler::Read(), XrdCl::FileStateHandler::ReadV(), XrdCl::LocalFileHandler::ReadV(), XrdCl::FileStateHandler::SetXAttr(), XrdCl::LocalFileHandler::Stat(), XrdCl::FileStateHandler::Stat(), XrdCl::LocalFileHandler::Sync(), XrdCl::FileStateHandler::Sync(), XrdCl::FileStateHandler::TimeOutRequests(), XrdCl::FileStateHandler::Truncate(), XrdCl::LocalFileHandler::Truncate(), XrdCl::FileStateHandler::TryOtherServer(), XrdCl::LocalFileHandler::VectorRead(), XrdCl::FileStateHandler::VectorRead(), XrdCl::LocalFileHandler::VectorWrite(), XrdCl::FileStateHandler::VectorWrite(), XrdCl::FileStateHandler::Visa(), XrdCl::FileStateHandler::Write(), XrdCl::LocalFileHandler::Write(), XrdCl::FileStateHandler::WriteV(), and XrdCl::LocalFileHandler::WriteV().

◆ FileSystemMsg

const uint64_t XrdCl::FileSystemMsg = 0x0000000000000100ULL

◆ JobMgrMsg

const uint64_t XrdCl::JobMgrMsg = 0x0000000000000400ULL

Definition at line 42 of file XrdClConstants.hh.

Referenced by XrdCl::JobManager::Start(), and XrdCl::JobManager::Stop().

◆ kLogXrdClHttp

◆ none

struct XrdCl::None XrdCl::none
static

◆ PlugInMgrMsg

const uint64_t XrdCl::PlugInMgrMsg = 0x0000000000000800ULL

◆ PollerMsg

◆ PostMasterMsg

◆ root_ctx_

Davix::Context* XrdCl::root_ctx_ = NULL

◆ root_davix_client_

Davix::DavPosix* XrdCl::root_davix_client_ = NULL

◆ root_davix_client_file_

Davix::DavPosix* XrdCl::root_davix_client_file_ = NULL

Definition at line 46 of file XrdClHttpFilePlugIn.cc.

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

◆ root_davix_context_

Davix::Context* XrdCl::root_davix_context_ = NULL

◆ stError

const uint16_t XrdCl::stError = 0x0001

An error occurred that could potentially be retried.

Definition at line 32 of file XrdClStatus.hh.

Referenced by XrdCl::FutureWrapperBase< Response >::~FutureWrapperBase(), Posix::_PRead(), XrdCl::CopyProcess::AddJob(), XrdCl::SIDManager::AllocateSID(), XrdCl::ZipArchive::AppendFile(), BuildPath(), XrdCl::FileStateHandler::Checkpoint(), XrdCl::Utils::CheckTPC(), XrdCl::Utils::CheckTPCLite(), XrdCl::FileStateHandler::ChkptWrt(), XrdCl::FileStateHandler::ChkptWrtV(), XrdCl::FileSystemPlugIn::ChMod(), XrdCl::Socket::ClassifyErrno(), Posix::Close(), XrdCl::FilePlugIn::Close(), XrdCl::HttpFilePlugIn::Close(), XrdCl::LocalFileHandler::Close(), XrdCl::FileStateHandler::Close(), XrdCl::ZipArchive::CloseFile(), XrdCl::Socket::Connect(), XrdCl::Socket::ConnectToAddress(), ConvertMode(), XrdCl::MessageUtils::CreateXAttrVec(), XrdCl::FileSystemPlugIn::DeepLocate(), XrdCl::FileSystemPlugIn::DelXAttr(), XrdCl::FileSystem::DelXAttr(), XrdCl::File::DelXAttr(), XrdCl::LocalFileHandler::DelXAttr(), XrdCl::FileStateHandler::DelXAttr(), XrdCl::FileSystem::DirList(), XrdCl::FileSystemPlugIn::DirList(), Posix::DirList(), DoCache(), DoCat(), DoCD(), DoChMod(), DoLocate(), DoLS(), DoMkDir(), DoMv(), DoPrepare(), DoQuery(), DoRm(), DoRmDir(), DoSpaceInfo(), DoStat(), DoStatVFS(), DoTail(), DoTruncate(), DoXAttr(), XrdCl::LocalFileHandler::ExecRequest(), XrdCl::FSExecutor::Execute(), XrdEc::block_t::fail_missing(), XrdCl::FilePlugIn::Fcntl(), XrdCl::LocalFileHandler::Fcntl(), XrdCl::FileStateHandler::Fcntl(), XrdCl::Channel::ForceDisconnect(), XrdCl::PostMaster::ForceDisconnect(), XrdCl::PostMaster::ForceReconnect(), XrdCl::XCpCtx::GetChunk(), XrdCl::ZipArchive::GetCRC32(), XrdCl::Utils::GetDirectoryEntries(), XrdCl::Socket::GetFlags(), XrdCl::XRootDTransport::GetHeader(), XrdCl::Utils::GetHostAddresses(), XrdCl::Utils::GetLocalCheckSum(), XrdCl::XRootDTransport::GetMore(), XrdCl::ZipArchive::GetOffset(), XrdCl::CheckSumHelper::GetRawCheckSum(), XrdCl::Utils::GetRemoteCheckSum(), XrdCl::AsyncDiscardReader::GetResponse(), XrdCl::AsyncRawReader::GetResponse(), XrdCl::XRootDTransport::GetSignature(), XrdCl::Socket::GetSockOpt(), XrdCl::FileSystemUtils::GetSpaceInfo(), XrdCl::FileSystemPlugIn::GetXAttr(), XrdCl::FileSystem::GetXAttr(), XrdCl::File::GetXAttr(), XrdCl::LocalFileHandler::GetXAttr(), XrdCl::FileStateHandler::GetXAttr(), XrdCl::AsyncSocketHandler::HandleHandShake(), XrdCl::ZipListHandler::HandleResponse(), XrdCl::MetalinkReadHandler::HandleResponse(), XrdCl::FutureWrapper< Response >::HandleResponse(), XrdCl::ChunkHandler::HandleResponse(), XrdCl::MetalinkOpenHandler::HandleResponseWithHosts(), XrdCl::CheckSumHelper::Initialize(), XrdCl::Stream::Initialize(), XrdCl::XCpCtx::Initialize(), XrdCl::Socket::Initialize(), XrdCl::Status::IsError(), XrdCl::XRootDTransport::IsStreamBroken(), XrdCl::ZipArchive::List(), XrdCl::FileSystemPlugIn::ListXAttr(), XrdCl::FileSystem::ListXAttr(), XrdCl::File::ListXAttr(), XrdCl::LocalFileHandler::ListXAttr(), XrdCl::FileStateHandler::ListXAttr(), XrdCl::FileSystemPlugIn::Locate(), main(), XrdCl::FileSystemPlugIn::MkDir(), Posix::MkDir(), XrdCl::LocalFileHandler::MkdirPath(), XrdCl::FileSystemPlugIn::Mv(), XrdCl::AsyncSocketHandler::OnConnectionReturn(), XrdCl::AsyncSocketHandler::OnHeaderCorruption(), XrdCl::AsyncSocketHandler::OnRead(), XrdCl::AsyncSocketHandler::OnReadWhileHandshaking(), XrdCl::AsyncSocketHandler::OnTimeoutWhileHandshaking(), XrdCl::AsyncSocketHandler::OnWrite(), XrdCl::FilePlugIn::Open(), xrdcl_proxy::ProxyPrefixFile::Open(), XrdCl::HttpFilePlugIn::Open(), Posix::Open(), XrdCl::FileStateHandler::Open(), XrdCl::EcHandler::Open(), XrdCl::ZipArchive::OpenArchive(), XrdCl::ZipArchive::OpenFile(), XrdCl::FilePlugIn::PgRead(), XrdCl::ZipArchive::PgRead(), XrdCl::FileStateHandler::PgReadImpl(), XrdCl::FileStateHandler::PgReadRetry(), XrdCl::FileStateHandler::PgWrite(), XrdCl::FilePlugIn::PgWrite(), XrdCl::EcHandler::PgWrite(), XrdCl::FileStateHandler::PgWriteImpl(), XrdCl::FileSystemPlugIn::Ping(), XrdCl::Socket::Poll(), Posix::PReadVec(), XrdCl::CopyProcess::Prepare(), XrdCl::FileSystemPlugIn::Prepare(), XrdCl::XRootDMsgHandler::Process(), XrdCl::Utils::ProcessConfig(), ProcessStatQuery(), XrdCl::FileSystemPlugIn::Protocol(), Posix::PWrite(), XrdCl::FileSystemPlugIn::Query(), XrdCl::Stream::Query(), XrdCl::XRootDTransport::Query(), XrdCl::PostMaster::QueryTransport(), XrdCl::AsyncMsgReader::Read(), XrdCl::Socket::Read(), XrdCl::AsyncDiscardReader::Read(), XrdCl::AsyncRawReader::Read(), XrdCl::AsyncVectorReader::Read(), XrdEc::block_t::read(), XrdCl::FileStateHandler::Read(), XrdCl::EcHandler::Read(), XrdCl::FilePlugIn::Read(), XrdCl::HttpFilePlugIn::Read(), XrdCl::LocalFileHandler::Read(), XrdCl::ZipArchive::Read(), XrdCl::Socket::ReadRaw(), XrdCl::Socket::ReadV(), XrdCl::FileStateHandler::ReadV(), XrdCl::LocalFileHandler::ReadV(), XrdCl::PostMaster::Redirect(), XrdCl::MessageUtils::RedirectMessage(), XrdCl::PostMaster::RegisterEventHandler(), XrdCl::PostMaster::RemoveEventHandler(), Posix::Rename(), XrdCl::InQueue::ReportTimeout(), XrdCl::FileSystemPlugIn::Rm(), XrdCl::FileSystemPlugIn::RmDir(), Posix::RmDir(), XrdCl::CopyProcess::Run(), XrdCl::ClassicCopyJob::Run(), XrdCl::ThirdPartyCopyJob::Run(), XrdCl::Operation< HasHndl >::Run(), XrdCl::PostMaster::Send(), XrdCl::Stream::Send(), XrdCl::Socket::Send(), XrdCl::AsyncSocketHandler::SendHSMsg(), XrdCl::FileSystemPlugIn::SendInfo(), XrdCl::MessageUtils::SendMessage(), XrdCl::Socket::SetFlags(), XrdCl::Socket::SetSockOpt(), XrdCl::FileSystemPlugIn::SetXAttr(), XrdCl::FileSystem::SetXAttr(), XrdCl::File::SetXAttr(), XrdCl::LocalFileHandler::SetXAttr(), XrdCl::FileStateHandler::SetXAttr(), XrdCl::EcHandler::Stat(), XrdCl::FilePlugIn::Stat(), XrdCl::HttpFilePlugIn::Stat(), XrdCl::ZipArchive::Stat(), XrdCl::FileSystemPlugIn::Stat(), Posix::Stat(), XrdCl::LocalFileHandler::Stat(), XrdCl::FileStateHandler::Stat(), XrdCl::FileSystemPlugIn::StatVFS(), XrdCl::FilePlugIn::Sync(), XrdCl::LocalFileHandler::Sync(), XrdCl::FileStateHandler::Sync(), XrdCl::Stream::Tick(), XrdCl::FileStateHandler::TimeOutRequests(), XrdCl::Socket::TlsHandShake(), XrdCl::FileSystemPlugIn::Truncate(), XrdCl::FileStateHandler::Truncate(), XrdCl::FilePlugIn::Truncate(), XrdCl::LocalFileHandler::Truncate(), XrdCl::FileStateHandler::TryOtherServer(), Posix::Unlink(), XrdCl::XRootDTransport::UnMarchalStatusMore(), XrdCl::XRootDTransport::UnMarshallBody(), XrdCl::XRootDTransport::UnMarshalStatusBody(), XrdCl::ZipArchive::UpdateMetadata(), XrdCl::FilePlugIn::VectorRead(), XrdCl::LocalFileHandler::VectorRead(), XrdCl::HttpFilePlugIn::VectorRead(), XrdEc::Reader::VectorRead(), XrdCl::FileStateHandler::VectorRead(), XrdCl::LocalFileHandler::VectorWrite(), XrdCl::FilePlugIn::VectorWrite(), XrdCl::FileStateHandler::VectorWrite(), XrdCl::FilePlugIn::Visa(), XrdCl::LocalFileHandler::Visa(), XrdCl::FileStateHandler::Visa(), XrdCl::MessageUtils::WaitForResponse(), XrdCl::FileStateHandler::Write(), XrdCl::ZipArchive::Write(), XrdCl::EcHandler::Write(), XrdCl::FilePlugIn::Write(), XrdCl::HttpFilePlugIn::Write(), XrdCl::LocalFileHandler::Write(), XrdCl::XRootDMsgHandler::WriteMessageBody(), XrdCl::Socket::WriteRaw(), XrdCl::FileStateHandler::WriteV(), XrdCl::LocalFileHandler::WriteV(), and XrdCl::FilePlugIn::WriteV().

◆ stFatal

◆ stOK

◆ suAlreadyDone

const uint16_t XrdCl::suAlreadyDone = 4

◆ suContinue

◆ suDone

◆ suNotStarted

const uint16_t XrdCl::suNotStarted = 5

Definition at line 43 of file XrdClStatus.hh.

◆ suPartial

const uint16_t XrdCl::suPartial = 3

◆ suRetry

◆ TaskMgrMsg

const uint64_t XrdCl::TaskMgrMsg = 0x0000000000000040ULL

◆ theDefaultInts

std::unordered_map<std::string, int> XrdCl::theDefaultInts
static

Definition at line 122 of file XrdClConstants.hh.

Referenced by XrdCl::Env::GetDefaultIntValue().

◆ theDefaultStrs

std::unordered_map<std::string, std::string> XrdCl::theDefaultStrs
static
Initial value:
{
{ to_lower( "PollerPreference" ), DefaultPollerPreference },
{ to_lower( "NetworkStack" ), DefaultNetworkStack },
{ to_lower( "ClientMonitor" ), DefaultClientMonitor },
{ to_lower( "ClientMonitorParam" ), DefaultClientMonitorParam },
{ to_lower( "PlugInConfDir" ), DefaultPlugInConfDir },
{ to_lower( "PlugIn" ), DefaultPlugIn },
{ to_lower( "ReadRecovery" ), DefaultReadRecovery },
{ to_lower( "WriteRecovery" ), DefaultWriteRecovery },
{ to_lower( "OpenRecovery" ), DefaultOpenRecovery },
{ to_lower( "GlfnRedirector" ), DefaultGlfnRedirector },
{ to_lower( "TlsDbgLvl" ), DefaultTlsDbgLvl },
{ to_lower( "ClConfDir" ), DefaultClConfDir },
{ to_lower( "DefaultClConfFile" ), DefaultClConfFile },
{ to_lower( "CpTarget" ), DefaultCpTarget }
}
const char *const DefaultClConfFile
const char *const DefaultCpTarget
const char *const DefaultClConfDir
const char *const DefaultClientMonitorParam
const char *const DefaultOpenRecovery
const char *const DefaultPlugIn
const char *const DefaultPollerPreference
const char *const DefaultNetworkStack
static std::string to_lower(std::string str)
const char *const DefaultPlugInConfDir
const char *const DefaultReadRecovery
const char *const DefaultWriteRecovery
const char *const DefaultGlfnRedirector
const char *const DefaultTlsDbgLvl
const char *const DefaultClientMonitor

Definition at line 167 of file XrdClConstants.hh.

Referenced by XrdCl::Env::GetDefaultStringValue().

◆ TlsMsg

const uint64_t XrdCl::TlsMsg = 0x0000000000002000ULL

Definition at line 45 of file XrdClConstants.hh.

Referenced by XrdCl::Tls::Connect(), and InitTLS().

◆ UtilityMsg

◆ XRootDMsg

◆ XRootDTransportMsg

◆ ZipMsg

const uint64_t XrdCl::ZipMsg = 0x0000000000004000ULL