XRootD
Loading...
Searching...
No Matches
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.
 
typedef Buffer BinaryDataInfo
 Binary buffer.
 
typedef ChModImpl< false > ChMod
 
typedef std::vector< ChunkInfoChunkList
 List of chunks.
 
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.
 
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.
 

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.
 
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.
 
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.
 
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.
 
ChkptWrtVImpl< false > ChkptWrtV (Ctx< File > file, Arg< uint64_t > offset, Arg< std::vector< iovec > > iov, uint16_t timeout=0)
 Factory for creating ChkptWrtVImpl objects.
 
CloseImpl< false > Close (Ctx< File > file, uint16_t timeout=0)
 Factory for creating CloseImpl objects.
 
CloseArchiveImpl< false > CloseArchive (Ctx< ZipArchive > zip, uint16_t timeout=0)
 Factory for creating CloseFileImpl objects.
 
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.
 
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.
 
OpenArchiveImpl< false > OpenArchive (Ctx< ZipArchive > zip, Arg< std::string > fn, Arg< OpenFlags::Flags > flags, uint16_t timeout=0)
 Factory for creating OpenArchiveImpl objects.
 
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.
 
template<class Container >
ParallelOperation< false > Parallel (Container &&container)
 Factory function for creating parallel operation from a vector.
 
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.
 
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.
 
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.
 
void PipesToVec (std::vector< Pipeline > &)
 Helper function for converting parameter pack into a vector.
 
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.
 
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.
 
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.
 
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.
 
SyncImpl< false > Sync (Ctx< File > file, uint16_t timeout=0)
 Factory for creating SyncImpl objects.
 
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.
 
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.
 
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.
 
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.
 
ZipWriteImpl< false > Write (Ctx< ZipArchive > zip, Arg< uint32_t > size, Arg< const void * > buffer, uint16_t timeout=0)
 Factory for creating ArchiveReadImpl objects.
 
WriteVImpl< false > WriteV (Ctx< File > file, Arg< uint64_t > offset, Arg< std::vector< iovec > > iov, uint16_t timeout=0)
 Factory for creating WriteVImpl objects.
 

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.
 
const uint16_t errConnectionError = 108
 
const uint16_t errCorruptedHeader = 307
 
const uint16_t errDataError = 14
 data is corrupted
 
const uint16_t errErrorResponse = 400
 
const uint16_t errFcntl = 4
 failed manipulate file descriptor
 
const uint16_t errHandShakeFailed = 202
 
const uint16_t errInProgress = 10
 
const uint16_t errInternal = 7
 Internal error.
 
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.
 
const uint16_t errNone = 0
 No error.
 
const uint16_t errNotFound = 304
 
const uint16_t errNotImplemented = 15
 Operation is not implemented.
 
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.
 
const uint16_t errPoll = 5
 error while polling descriptors
 
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.
 
const uint16_t errRetry = 1
 Try again for whatever reason.
 
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.
 
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.
 
const uint16_t stFatal = 0x0003
 Fatal error, it's still an error.
 
const uint16_t stOK = 0x0000
 Everything went OK.
 
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 ReadImpl<false>

◆ 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 PgReadImpl<false>

◆ 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
typedef sequence< Ns... > type sequence<Ns...>

◆ 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
typedef typename type type typename seq_gen<I - 1, I - 1, Ns...>::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 = 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 1055 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 1120 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 }
AppendFile operation (.
Derived< HasHndl > Timeout(uint16_t timeout)
Set operation timeout.

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 }

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(FUNC &&func, std::tuple< ARGs... > &tup) -> decltype(tuple_call_impl(func, tup, typename seq_gen< sizeof...(ARGs)>::type{}))
Definition XrdClApply.hh:64

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}
Object stat info.
uint64_t GetSize() const
Get size (in bytes)
std::vector< char > buffer_t
a buffer type
Flags
Open flags, may be or'd when appropriate.
bool IsOK() const
We're fine.

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 }
Checkpoint operation (.

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 }
Checkpointed write operation (.

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 }
Checkpointed WriteV operation (.

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 }
Close operation (.

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

Referenced by XrdCl::HttpFilePlugIn::Close(), 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 }
CloseArchive operation (.

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 operation (.

◆ 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 bulk operation (.

◆ 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.

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

+ Here is the call 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::map< std::string, std::string > ParamsMap
Definition XrdClURL.hh:33
const ParamsMap & GetParams() const
Get the URL params.
Definition XrdClURL.hh:239
std::vector< std::string > mdtacgi
std::vector< std::string > plgr
std::vector< std::string > dtacgi

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 }
void Get(Type &object)
Retrieve the object being held.

References XrdCl::AnyObject::Get().

Referenced by GetResponse(), XrdCl::FutureWrapper< Response >::HandleResponse(), XrdCl::TaskWrapper< Response, Return >::HandleResponse(), and XrdCl::FunctionWrapper< Response >::HandleResponseWithHosts().

+ Here is the call graph for this function:
+ Here is the caller 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 GetResponse(), and 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 operation (.

◆ 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 bulk operation (.

◆ 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().

+ 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 }
ZipList operation (.

◆ 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 bulk operation (.

◆ 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 }
ListXAttr bulk operation (.

◆ 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 }
Open operation (.

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

Referenced by XrdCl::ActionExecutor::Execute(), XrdCl::HttpFilePlugIn::Open(), 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 }
OpenArchive operation (.

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 }
OpenFile operation (.

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 }
void PipesToVec(std::vector< Pipeline > &)
Helper function for converting parameter pack into a vector.
ParallelOperation< false > Parallel(Container &&container)
Factory function for creating parallel operation from a vector.

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}
XrdOucString File
std::vector< std::string > ToColumns(const std::string &row)
Split a row into columns.

References File, XrdCl::Utils::splitString(), 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 }
PgRead operation (.

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 }
PgWrite operation (.

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(), PipesToVec(), PipesToVec(), 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 }
Read operation (.

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

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

+ 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().

+ Here is the call 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, "[0x%x] 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, "[0x%x] Read %d bytes of remote data at offset %d.",
160 &me, rsp.GetLength(), 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, "[0x%x] 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, "[0x%x] Read %d bytes of remote data at "
191 "offset %d.", &me, r.GetLength(), 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 }
void Set(Type object, bool own=true)
bool IsOpen() const
Check if the file is open.
Definition XrdClFile.cc:846
void Dump(uint64_t topic, const char *format,...)
Print a dump message.
Definition XrdClLog.cc:299
virtual void HandleResponse(XRootDStatus *status, AnyObject *response)
Utility class for inflating a compressed buffer.
void QueueRsp(const XRootDStatus &st, uint64_t offset, buffer_t &&buffer)
void QueueReq(uint64_t offset, uint32_t length, void *buffer, ResponseHandler *handler)
ReadTrait< RSP >::RET RdWithRsp(Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout=0)
std::future< XRootDStatus > Async(Pipeline pipeline, uint16_t timeout=0)
XrdSysError Log
Definition XrdConfig.cc:111
uint32_t uncompressedSize
std::unique_ptr< Extra > extra
uint16_t compressionMethod
bool HasDataDescriptor()
uint32_t compressedSize
bool IsZIP64() const

◆ 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
void SetTopicName(uint64_t topic, std::string name)
Map a topic number to a string.
Definition XrdClLog.cc:163

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 operation (.

◆ 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 bulk operation (.

◆ 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 }
Stat operation (.

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

Referenced by DoStat(), XrdCl::HttpFilePlugIn::Open(), XrdCl::HttpFilePlugIn::Stat(), and XrdCl::HttpFileSystemPlugIn::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 }
ZipStat operation (.

◆ 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 }
Sync operation (.

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:

◆ 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 }
Truncate operation (.

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 }
VectorRead operation (.

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 }
VectorWrite operation (.

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 }
Write operation (.

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:

◆ 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 }
WriteV operation (.

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().

◆ 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.

◆ 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.

◆ 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().

◆ 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::FileStateHandler::Close(), XrdCl::HttpFilePlugIn::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(), XrdCl::FileStateHandler::Open(), XrdCl::HttpFilePlugIn::Open(), xrdcl_proxy::ProxyPrefixFile::Open(), XrdCl::ZipArchive::OpenArchive(), XrdCl::ZipArchive::OpenFile(), XrdCl::ZipArchive::PgRead(), XrdCl::FileStateHandler::PgReadImpl(), XrdCl::FileStateHandler::PgWriteImpl(), XrdCl::Socket::Poll(), XrdCl::PostMaster::QueryTransport(), XrdCl::FileStateHandler::Read(), XrdCl::HttpFilePlugIn::Read(), XrdCl::ZipArchive::Read(), XrdEc::block_t::read(), XrdCl::Socket::ReadRaw(), XrdCl::FileStateHandler::ReadV(), XrdCl::PostMaster::Redirect(), XrdCl::Socket::SetFlags(), XrdCl::Socket::SetSockOpt(), XrdCl::FileStateHandler::SetXAttr(), XrdCl::EcHandler::Stat(), XrdCl::FileStateHandler::Stat(), XrdCl::HttpFilePlugIn::Stat(), XrdCl::ZipArchive::Stat(), XrdCl::ZipArchive::Stat(), XrdCl::FileStateHandler::Sync(), XrdCl::Socket::TlsHandShake(), XrdCl::FileStateHandler::Truncate(), XrdCl::FileStateHandler::TryOtherServer(), XrdCl::ZipArchive::UpdateMetadata(), XrdCl::FileStateHandler::VectorRead(), XrdCl::HttpFilePlugIn::VectorRead(), XrdCl::FileStateHandler::VectorWrite(), XrdCl::FileStateHandler::Visa(), XrdCl::FileStateHandler::Write(), XrdCl::HttpFilePlugIn::Write(), XrdCl::ZipArchive::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::FileStateHandler::Close(), XrdCl::LocalFileHandler::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::FileStateHandler::Stat(), XrdCl::LocalFileHandler::Stat(), XrdCl::FileStateHandler::Sync(), XrdCl::LocalFileHandler::Sync(), XrdCl::FileStateHandler::TimeOutRequests(), XrdCl::FileStateHandler::Truncate(), XrdCl::LocalFileHandler::Truncate(), XrdCl::FileStateHandler::TryOtherServer(), XrdCl::FileStateHandler::VectorRead(), XrdCl::LocalFileHandler::VectorRead(), XrdCl::FileStateHandler::VectorWrite(), XrdCl::LocalFileHandler::VectorWrite(), XrdCl::FileStateHandler::Visa(), XrdCl::FileStateHandler::Write(), 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::EcHandler::Close(), XrdCl::FilePlugIn::Close(), XrdCl::FileStateHandler::Close(), XrdCl::HttpFilePlugIn::Close(), XrdCl::LocalFileHandler::Close(), XrdCl::ZipArchive::CloseFile(), XrdCl::Socket::Connect(), XrdCl::Socket::ConnectToAddress(), ConvertMode(), XrdCl::MessageUtils::CreateXAttrVec(), XrdCl::MessageUtils::CreateXAttrVec(), XrdCl::FileSystemPlugIn::DeepLocate(), XrdCl::File::DelXAttr(), XrdCl::FileStateHandler::DelXAttr(), XrdCl::FileSystem::DelXAttr(), XrdCl::FileSystemPlugIn::DelXAttr(), XrdCl::LocalFileHandler::DelXAttr(), Posix::DirList(), XrdCl::FileSystem::DirList(), XrdCl::FileSystemPlugIn::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::FileStateHandler::Fcntl(), XrdCl::LocalFileHandler::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::File::GetXAttr(), XrdCl::FileStateHandler::GetXAttr(), XrdCl::FileSystem::GetXAttr(), XrdCl::FileSystemPlugIn::GetXAttr(), XrdCl::LocalFileHandler::GetXAttr(), XrdCl::AsyncSocketHandler::HandleHandShake(), XrdCl::ChunkHandler::HandleResponse(), XrdCl::FutureWrapper< Response >::HandleResponse(), XrdCl::MetalinkReadHandler::HandleResponse(), XrdCl::ZipListHandler::HandleResponse(), XrdCl::MetalinkOpenHandler::HandleResponseWithHosts(), XrdCl::CheckSumHelper::Initialize(), XrdCl::Socket::Initialize(), XrdCl::Stream::Initialize(), XrdCl::XCpCtx::Initialize(), XrdCl::Status::IsError(), XrdCl::XRootDTransport::IsStreamBroken(), XrdCl::ZipArchive::List(), XrdCl::File::ListXAttr(), XrdCl::FileStateHandler::ListXAttr(), XrdCl::FileSystem::ListXAttr(), XrdCl::FileSystemPlugIn::ListXAttr(), XrdCl::LocalFileHandler::ListXAttr(), XrdCl::FileSystemPlugIn::Locate(), Posix::MkDir(), XrdCl::FileSystemPlugIn::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(), Posix::Open(), XrdCl::EcHandler::Open(), XrdCl::FilePlugIn::Open(), XrdCl::FileStateHandler::Open(), XrdCl::HttpFilePlugIn::Open(), xrdcl_proxy::ProxyPrefixFile::Open(), XrdCl::ZipArchive::OpenArchive(), XrdCl::ZipArchive::OpenFile(), XrdCl::FilePlugIn::PgRead(), XrdCl::ZipArchive::PgRead(), XrdCl::FileStateHandler::PgReadImpl(), XrdCl::FileStateHandler::PgReadRetry(), XrdCl::EcHandler::PgWrite(), XrdCl::FilePlugIn::PgWrite(), XrdCl::FileStateHandler::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::AsyncDiscardReader::Read(), XrdCl::AsyncMsgReader::Read(), XrdCl::AsyncRawReader::Read(), XrdCl::AsyncVectorReader::Read(), XrdCl::EcHandler::Read(), XrdCl::FilePlugIn::Read(), XrdCl::FilePlugIn::Read(), XrdCl::FileStateHandler::Read(), XrdCl::HttpFilePlugIn::Read(), XrdCl::LocalFileHandler::Read(), XrdCl::Socket::Read(), XrdCl::ZipArchive::Read(), XrdEc::block_t::read(), XrdCl::Socket::ReadRaw(), XrdCl::FileStateHandler::ReadV(), XrdCl::LocalFileHandler::ReadV(), XrdCl::Socket::ReadV(), XrdCl::PostMaster::Redirect(), XrdCl::MessageUtils::RedirectMessage(), XrdCl::PostMaster::RegisterEventHandler(), XrdCl::PostMaster::RemoveEventHandler(), Posix::Rename(), XrdCl::InQueue::ReportTimeout(), XrdCl::FileSystemPlugIn::Rm(), Posix::RmDir(), XrdCl::FileSystemPlugIn::RmDir(), XrdCl::ClassicCopyJob::Run(), XrdCl::CopyProcess::Run(), XrdCl::Operation< HasHndl >::Run(), XrdCl::ThirdPartyCopyJob::Run(), XrdCl::PostMaster::Send(), XrdCl::Socket::Send(), XrdCl::Stream::Send(), XrdCl::AsyncSocketHandler::SendHSMsg(), XrdCl::FileSystemPlugIn::SendInfo(), XrdCl::MessageUtils::SendMessage(), XrdCl::Socket::SetFlags(), XrdCl::Socket::SetSockOpt(), XrdCl::File::SetXAttr(), XrdCl::FileStateHandler::SetXAttr(), XrdCl::FileSystem::SetXAttr(), XrdCl::FileSystemPlugIn::SetXAttr(), XrdCl::LocalFileHandler::SetXAttr(), Posix::Stat(), XrdCl::EcHandler::Stat(), XrdCl::FilePlugIn::Stat(), XrdCl::FileStateHandler::Stat(), XrdCl::FileSystemPlugIn::Stat(), XrdCl::HttpFilePlugIn::Stat(), XrdCl::LocalFileHandler::Stat(), XrdCl::ZipArchive::Stat(), XrdCl::ZipArchive::Stat(), XrdCl::FileSystemPlugIn::StatVFS(), XrdCl::FilePlugIn::Sync(), XrdCl::FileStateHandler::Sync(), XrdCl::LocalFileHandler::Sync(), XrdCl::Stream::Tick(), XrdCl::FileStateHandler::TimeOutRequests(), XrdCl::Socket::TlsHandShake(), XrdCl::FilePlugIn::Truncate(), XrdCl::FileStateHandler::Truncate(), XrdCl::FileSystemPlugIn::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::FileStateHandler::VectorRead(), XrdCl::HttpFilePlugIn::VectorRead(), XrdCl::LocalFileHandler::VectorRead(), XrdEc::Reader::VectorRead(), XrdCl::FilePlugIn::VectorWrite(), XrdCl::FileStateHandler::VectorWrite(), XrdCl::LocalFileHandler::VectorWrite(), XrdCl::FilePlugIn::Visa(), XrdCl::FileStateHandler::Visa(), XrdCl::LocalFileHandler::Visa(), XrdCl::MessageUtils::WaitForResponse(), XrdCl::EcHandler::Write(), XrdCl::FilePlugIn::Write(), XrdCl::FilePlugIn::Write(), XrdCl::FilePlugIn::Write(), XrdCl::FileStateHandler::Write(), XrdCl::FileStateHandler::Write(), XrdCl::FileStateHandler::Write(), XrdCl::HttpFilePlugIn::Write(), XrdCl::LocalFileHandler::Write(), XrdCl::ZipArchive::Write(), XrdCl::XRootDMsgHandler::WriteMessageBody(), XrdCl::Socket::WriteRaw(), XrdCl::FilePlugIn::WriteV(), XrdCl::FileStateHandler::WriteV(), and XrdCl::LocalFileHandler::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.

123 {
124 { to_lower( "SubStreamsPerChannel" ), DefaultSubStreamsPerChannel },
125 { to_lower( "ConnectionWindow" ), DefaultConnectionWindow },
126 { to_lower( "ConnectionRetry" ), DefaultConnectionRetry },
127 { to_lower( "RequestTimeout" ), DefaultRequestTimeout },
128 { to_lower( "StreamTimeout" ), DefaultStreamTimeout },
129 { to_lower( "TimeoutResolution" ), DefaultTimeoutResolution },
130 { to_lower( "StreamErrorWindow" ), DefaultStreamErrorWindow },
131 { to_lower( "RunForkHandler" ), DefaultRunForkHandler },
132 { to_lower( "RedirectLimit" ), DefaultRedirectLimit },
133 { to_lower( "WorkerThreads" ), DefaultWorkerThreads },
134 { to_lower( "CPChunkSize" ), DefaultCPChunkSize },
135 { to_lower( "CPParallelChunks" ), DefaultCPParallelChunks },
136 { to_lower( "DataServerTTL" ), DefaultDataServerTTL },
137 { to_lower( "LoadBalancerTTL" ), DefaultLoadBalancerTTL },
138 { to_lower( "CPInitTimeout" ), DefaultCPInitTimeout },
139 { to_lower( "CPTPCTimeout" ), DefaultCPTPCTimeout },
140 { to_lower( "CPTimeout" ), DefaultCPTimeout },
141 { to_lower( "TCPKeepAlive" ), DefaultTCPKeepAlive },
142 { to_lower( "TCPKeepAliveTime" ), DefaultTCPKeepAliveTime },
143 { to_lower( "TCPKeepAliveInterval" ), DefaultTCPKeepAliveInterval },
144 { to_lower( "TCPKeepAliveProbes" ), DefaultTCPKeepAliveProbes },
145 { to_lower( "MultiProtocol" ), DefaultMultiProtocol },
146 { to_lower( "ParallelEvtLoop" ), DefaultParallelEvtLoop },
147 { to_lower( "MetalinkProcessing" ), DefaultMetalinkProcessing },
148 { to_lower( "LocalMetalinkFile" ), DefaultLocalMetalinkFile },
149 { to_lower( "XRateThreshold" ), DefaultXRateThreshold },
150 { to_lower( "XCpBlockSize" ), DefaultXCpBlockSize },
151 { to_lower( "NoDelay" ), DefaultNoDelay },
152 { to_lower( "AioSignal" ), DefaultAioSignal },
153 { to_lower( "PreferIPv4" ), DefaultPreferIPv4 },
154 { to_lower( "MaxMetalinkWait" ), DefaultMaxMetalinkWait },
155 { to_lower( "PreserveLocateTried" ), DefaultPreserveLocateTried },
156 { to_lower( "NotAuthorizedRetryLimit" ), DefaultNotAuthorizedRetryLimit },
157 { to_lower( "PreserveXAttrs" ), DefaultPreserveXAttrs },
158 { to_lower( "NoTlsOK" ), DefaultNoTlsOK },
159 { to_lower( "TlsNoData" ), DefaultTlsNoData },
160 { to_lower( "TlsMetalink" ), DefaultTlsMetalink },
161 { to_lower( "ZipMtlnCksum" ), DefaultZipMtlnCksum },
162 { to_lower( "IPNoShuffle" ), DefaultIPNoShuffle },
163 { to_lower( "WantTlsOnNoPgrw" ), DefaultWantTlsOnNoPgrw },
164 { to_lower( "RetryWrtAtLBLimit" ), DefaultRetryWrtAtLBLimit }
165 };
const int DefaultPreserveLocateTried
const int DefaultRunForkHandler
const int DefaultRedirectLimit
const int DefaultCPInitTimeout
const int DefaultXRateThreshold
const int DefaultLoadBalancerTTL
const int DefaultMaxMetalinkWait
const int DefaultTCPKeepAliveProbes
const int DefaultCPChunkSize
const int DefaultRetryWrtAtLBLimit
const int DefaultWantTlsOnNoPgrw
const int DefaultStreamErrorWindow
const int DefaultMultiProtocol
const int DefaultConnectionRetry
const int DefaultIPNoShuffle
const int DefaultSubStreamsPerChannel
const int DefaultDataServerTTL
const int DefaultCPParallelChunks
const int DefaultTlsMetalink
const int DefaultTimeoutResolution
const int DefaultStreamTimeout
const int DefaultLocalMetalinkFile
const int DefaultMetalinkProcessing
static std::string to_lower(std::string str)
const int DefaultTCPKeepAliveInterval
const int DefaultXCpBlockSize
const int DefaultCPTimeout
const int DefaultTCPKeepAlive
const int DefaultRequestTimeout
const int DefaultTCPKeepAliveTime
const int DefaultPreserveXAttrs
const int DefaultPreferIPv4
const int DefaultNotAuthorizedRetryLimit
const int DefaultWorkerThreads
const int DefaultAioSignal
const int DefaultCPTPCTimeout
const int DefaultNoDelay
const int DefaultTlsNoData
const int DefaultNoTlsOK
const int DefaultParallelEvtLoop
const int DefaultZipMtlnCksum

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
const char *const DefaultPlugInConfDir
const char *const DefaultReadRecovery
const char *const DefaultWriteRecovery
const char *const DefaultGlfnRedirector
const char *const DefaultTlsDbgLvl

Definition at line 167 of file XrdClConstants.hh.

168 {
169 { to_lower( "PollerPreference" ), DefaultPollerPreference },
170 { to_lower( "NetworkStack" ), DefaultNetworkStack },
171 { to_lower( "ClientMonitor" ), DefaultClientMonitor },
172 { to_lower( "ClientMonitorParam" ), DefaultClientMonitorParam },
173 { to_lower( "PlugInConfDir" ), DefaultPlugInConfDir },
174 { to_lower( "PlugIn" ), DefaultPlugIn },
175 { to_lower( "ReadRecovery" ), DefaultReadRecovery },
176 { to_lower( "WriteRecovery" ), DefaultWriteRecovery },
177 { to_lower( "OpenRecovery" ), DefaultOpenRecovery },
178 { to_lower( "GlfnRedirector" ), DefaultGlfnRedirector },
179 { to_lower( "TlsDbgLvl" ), DefaultTlsDbgLvl },
180 { to_lower( "ClConfDir" ), DefaultClConfDir },
181 { to_lower( "DefaultClConfFile" ), DefaultClConfFile },
182 { to_lower( "CpTarget" ), DefaultCpTarget }
183 };
const char *const DefaultClientMonitor

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