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< ChunkInfo > | ChunkList
| 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< HostInfo > | HostList
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< XRootDStatus > | Async (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)
EcHandler * | GetEcHandler (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_list > | 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)
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
template<typename Response>
Response | NullRef< Response >::value
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

  exec | full path name to executable provided by XrdSysUtils::ExecName
  parms | Value 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

typedef Buffer XrdCl::BinaryDataInfo

Binary buffer.

Definition at line 336 of file XrdClXRootDResponses.hh.

## ChMod

typedef ChModImpl<false> XrdCl::ChMod

Definition at line 521 of file XrdClFileSystemOperations.hh.

## ChunkList

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

List of chunks.

Definition at line 1056 of file XrdClXRootDResponses.hh.

## CloseFile

typedef CloseFileImpl<false> XrdCl::CloseFile

Definition at line 475 of file XrdClZipOperations.hh.

## DeepLocate

typedef DeepLocateImpl<false> XrdCl::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

typedef FinalOperation XrdCl::Final

Definition at line 67 of file XrdClFinalOperation.hh.

## HostList

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

Definition at line 1121 of file XrdClXRootDResponses.hh.

## Locate

typedef LocateImpl<false> XrdCl::Locate

Definition at line 136 of file XrdClFileSystemOperations.hh.

## MkDir

typedef MkDirImpl<false> XrdCl::MkDir

Definition at line 427 of file XrdClFileSystemOperations.hh.

## Mv

typedef MvImpl<false> XrdCl::Mv

Definition at line 232 of file XrdClFileSystemOperations.hh.

## Ping

typedef PingImpl<false> XrdCl::Ping

Definition at line 560 of file XrdClFileSystemOperations.hh.

## Prepare

typedef PrepareImpl<false> XrdCl::Prepare

Definition at line 843 of file XrdClFileSystemOperations.hh.

## Protocol

typedef ProtocolImpl<false> XrdCl::Protocol

Definition at line 698 of file XrdClFileSystemOperations.hh.

## Query

typedef QueryImpl<false> XrdCl::Query

Definition at line 280 of file XrdClFileSystemOperations.hh.

## rcvry_func

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

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

Definition at line 161 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.

{
xattr_name = 0,
xattr_value = 1
};
XrdCl::xattr_name
@ xattr_name
Definition XrdClXRootDResponses.hh:282
XrdCl::xattr_value
@ xattr_value
Definition XrdClXRootDResponses.hh:283

## ChkPtCode

enum XrdCl::ChkPtCode

Checkpoint operation code.

Enumerator
BEGIN |
COMMIT |
ROLLBACK |

Definition at line 18 of file XrdClCheckpointOperation.hh.

{
BEGIN = kXR_ckpBegin, COMMIT = kXR_ckpCommit, ROLLBACK = kXR_ckpRollback
};
kXR_ckpRollback
static const int kXR_ckpRollback
Definition XProtocol.hh:215
kXR_ckpCommit
static const int kXR_ckpCommit
Definition XProtocol.hh:213
kXR_ckpBegin
static const int kXR_ckpBegin
Definition XProtocol.hh:212
XrdCl::BEGIN
@ BEGIN
Definition XrdClCheckpointOperation.hh:20
XrdCl::COMMIT
@ COMMIT
Definition XrdClCheckpointOperation.hh:20
XrdCl::ROLLBACK
@ ROLLBACK
Definition XrdClCheckpointOperation.hh:20

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

{
return AppendFileImpl<false>( std::move( zip ), std::move( fn ), std::move( crc32 ),
std::move( size ), std::move( buffer ) ).Timeout( timeout );
}
XrdCl::AppendFileImpl
AppendFile operation (.
Definition XrdClZipOperations.hh:375
XrdCl::ConcreteOperation::Timeout
Derived< HasHndl > Timeout(uint16_t timeout)
Set operation timeout.
Definition XrdClOperations.hh:647

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

Here is the call graph for this function:

## Apply() [1/2]

template<typename FUNC, typename ... ARGs>

auto XrdCl::Apply | ( | FUNC && | func,
|  | std::tuple< ARGs... > & | tup )->decltype(tuple_call_impl(func, tup, typenameseq_gen< sizeof...(ARGs)>::type{}))

inline static

Definition at line 64 of file XrdClApply.hh.

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

Referenced by Apply().

Here is the caller graph for this function:

## Apply() [2/2]

template<typename METH, typename OBJ, typename ... ARGs>

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

inline static

Definition at line 80 of file XrdClApply.hh.

{
return Apply( std::bind( method, &obj, std::placeholders::_1, std::placeholders::_2 ), tup );
}
XrdCl::Apply
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.

{
OpenFlags::Flags flags = OpenFlags::Read;
Access::Mode mode = Access::None;
uint16_t timeout = 60;
{
// deal with existing files
auto file = std::make_unique<XrdCl::File>(false);
XRootDStatus status = file->Open(url, flags, mode, timeout);
if (status.IsOK())
{
StatInfo* statinfo;
// file exists already, verify the size
status = file->Stat(false, statinfo, timeout);
if (status.IsOK())
{
if (statinfo->GetSize() < size)
{
std::cerr
<< "Error: file size is not sufficient, but I won't touch the file - aborting ...";
return false;
}
else
{
std::cout << "# ---> info: file exists and has sufficient size" << std::endl;
return true;
}
}
}
}
if (verify)
{
std::cerr << "Verify: file is missing or inaccessible: " << url << std::endl;
return false;
}
{
// deal with non-existing file
OpenFlags::Flags wflags = OpenFlags::New | OpenFlags::Write | OpenFlags::MakePath;
Access::Mode wmode = Access::UR | Access::UW | Access::UX;
auto file = std::make_unique<XrdCl::File>(false);
XRootDStatus status = file->Open(url, wflags, wmode, timeout);
if (status.IsOK())
{
if (viatruncate)
{
// create a file via truncation
status = file->Truncate(size, timeout);
if (!status.IsOK())
{
std::cerr << "Error: " << status.ToString() << " - empty file might be left behind!"
<< std::endl;
return false;
}
return true;
}
else
{
// create a file via writes
using buffer_t = std::vector<uint64_t>; //< data buffer
buffer_t buffer(32768);
size_t nbytes = 0;
while (nbytes < size)
{
size_t towrite = size - nbytes;
if (towrite > (buffer.size() * sizeof(uint64_t)))
towrite = buffer.size() * sizeof(uint64_t);
for (size_t i = 0; i < buffer.size(); ++i)
{
// we write the offset in this buffer
buffer[i] = nbytes / sizeof(uint64_t) + i;
}
status = file->Write(nbytes, towrite, buffer.data(), timeout);
if (!status.IsOK())
{
std::cerr << "Error: " << status.ToString() << " - failed to write file at offset "
<< nbytes << " - incomplete file might be left behind!" << std::endl;
return false;
}
nbytes += towrite;
}
}
return true;
}
else
{
std::cerr << "Error: " << status.ToString() << " - failed to create file!" << std::endl;
}
}
return false;
}
XrdCl::StatInfo
Object stat info.
Definition XrdClXRootDResponses.hh:401
XrdCl::StatInfo::GetSize
uint64_t GetSize() const
Get size (in bytes).
Definition XrdClXRootDResponses.cc:274
XrdCl::XRootDStatus
Request status.
Definition XrdClXRootDResponses.hh:219
XrdZip::buffer_t
std::vector< char > buffer_t
Definition XrdZipUtils.hh:56
XrdCl::Access::Mode
Mode
Access mode.
Definition XrdClFileSystem.hh:122
XrdCl::Access::UR
@ UR
owner readable
Definition XrdClFileSystem.hh:124
XrdCl::Access::UW
@ UW
owner writable
Definition XrdClFileSystem.hh:125
XrdCl::Access::None
@ None
Definition XrdClFileSystem.hh:123
XrdCl::Access::UX
@ UX
owner executable/browsable
Definition XrdClFileSystem.hh:126
XrdCl::OpenFlags::Flags
Flags
Open flags, may be or'd when appropriate.
Definition XrdClFileSystem.hh:76
XrdCl::OpenFlags::Read
@ Read
Open only for reading.
Definition XrdClFileSystem.hh:95
XrdCl::OpenFlags::New
@ New
Definition XrdClFileSystem.hh:86
XrdCl::OpenFlags::Write
@ Write
Open only for writing.
Definition XrdClFileSystem.hh:97
XrdCl::OpenFlags::MakePath
@ MakePath
Definition XrdClFileSystem.hh:84
XrdCl::Status::IsOK
bool IsOK() const
We're fine.
Definition XrdClStatus.hh:124

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 488 of file XrdClOperations.hh.

{
pipeline.Run( timeout );
return std::move( pipeline.ftr );
}

Referenced by XrdEc::Reader::Close(), XrdCl::ZipArchive::CloseArchive(), DoStat(), XrdCl::ActionExecutor::Execute(), XrdEc::Reader::Open(), XrdEc::StrmWriter::Open(), XrdCl::ZipArchive::OpenArchive(), XrdCl::ZipArchive::ReadFromImpl, 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.

{
return CheckpointImpl<false>( std::move( file ), std::move( code ) ).Timeout( timeout );
}
XrdCl::CheckpointImpl
Checkpoint operation (.
Definition XrdClCheckpointOperation.hh:29

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.

{
return ChkptWrtImpl<false>( std::move( file ), std::move( offset ),
std::move( size ), std::move( buffer ) ).Timeout( timeout );
}
XrdCl::ChkptWrtImpl
Checkpointed write operation (.
Definition XrdClCheckpointOperation.hh:84

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.

{
return ChkptWrtVImpl<false>( std::move( file ), std::move( offset ),
std::move( iov ) ).Timeout( timeout );
}
XrdCl::ChkptWrtVImpl
Checkpointed WriteV operation (.
Definition XrdClCheckpointOperation.hh:144
iov
Definition XrdOucIOVec.hh:65

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.

{
return CloseImpl<false>( std::move( file ) ).Timeout( timeout );
}
XrdCl::CloseImpl
Close operation (.
Definition XrdClFileOperations.hh:446

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.

{
return CloseArchiveImpl<false>( std::move( zip ) ).Timeout( timeout );
}
XrdCl::CloseArchiveImpl
CloseArchive operation (.
Definition XrdClZipOperations.hh:585

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.

{
delete status;
delete response;
delete hostList;
}

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.

{
return DelXAttrImpl<false>( std::move( file ), std::move( name ) );
}
XrdCl::DelXAttrImpl
DelXAttr operation (.
Definition XrdClFileOperations.hh:1206

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

{
return DelXAttrBulkImpl<false>( std::move( file ), std::move( attrs ) );
}
XrdCl::DelXAttrBulkImpl
DelXAttr bulk operation (.
Definition XrdClFileOperations.hh:1267

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

{
return DelXAttrFsImpl<false>( std::move( fs ), std::move( path ), std::move( name ) );
}
XrdCl::DelXAttrFsImpl
DelXAttr operation (.
Definition XrdClFileSystemOperations.hh:1091

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

{
return DelXAttrFsBulkImpl<false>( std::move( fs ), std::move( path ), std::move( attrs ) );
}
XrdCl::DelXAttrFsBulkImpl
DelXAttr bulk operation (.
Definition XrdClFileSystemOperations.hh:1155

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

{
std::thread t(
[file{ std::move(file) },
actions{ std::move(actions) },
t0,
&metric,
simulate,
&speed]() mutable
{
XrdSysSemaphore endsem(0);
XrdSysSemaphore closesem(0);
auto ending = std::make_shared<barrier_t>(endsem);
auto closing = std::make_shared<barrier_t>(closesem);
for (auto& p : actions)
{
auto& action = p.second;
auto tdelay = t0 ? ((p.first + t0) - XrdCl::Action::timeNow()) : 0;
if (tdelay > 0)
{
tdelay /= speed;
metric.delays[action.Name() + "::tloss"] += tdelay;
std::this_thread::sleep_for(std::chrono::milliseconds((int) (tdelay * 1000)));
}
else
{
metric.delays[action.Name() + "::tgain"] += tdelay;
}
mytimer_t timer;
action.Execute(ending, closing, metric, simulate);
metric.addDelays(action.Name(), "tnomi", action.NominalDuration());
metric.addDelays(action.Name(), "texec", timer.elapsed());
}
ending.reset();
closing.reset();
endsem.Wait();
file->GetProperty("LastURL", metric.url);
file.reset();
});
return t;
}
XrdCl::mytimer_t
Timer helper class.
Definition XrdClReplay.cc:156
XrdCl::Action::timeNow
static double timeNow()
Get curretn unix time in ns precision as a double.
Definition XrdClAction.hh:78

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

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.

{
const URL::ParamsMap &params = redirurl.GetParams();
// make sure all the xrdec. tokens are present and the values are sane
URL::ParamsMap::const_iterator itr = params.find( "xrdec.nbdta" );
if( itr == params.end() ) return nullptr;
uint8_t nbdta = std::stoul( itr->second );
itr = params.find( "xrdec.nbprt" );
if( itr == params.end() ) return nullptr;
uint8_t nbprt = std::stoul( itr->second );
itr = params.find( "xrdec.blksz" );
if( itr == params.end() ) return nullptr;
uint64_t blksz = std::stoul( itr->second );
itr = params.find( "xrdec.plgr" );
if( itr == params.end() ) return nullptr;
std::vector<std::string> plgr;
Utils::splitString( plgr, itr->second, "," );
if( plgr.size() < nbdta + nbprt ) return nullptr;
itr = params.find( "xrdec.objid" );
if( itr == params.end() ) return nullptr;
std::string objid = itr->second;
itr = params.find( "xrdec.format" );
if( itr == params.end() ) return nullptr;
size_t format = std::stoul( itr->second );
if( format != 1 ) return nullptr; // TODO use constant
std::vector<std::string> dtacgi;
itr = params.find( "xrdec.dtacgi" );
if( itr != params.end() )
{
Utils::splitString( dtacgi, itr->second, "," );
if( plgr.size() != dtacgi.size() ) return nullptr;
}
std::vector<std::string> mdtacgi;
itr = params.find( "xrdec.mdtacgi" );
if( itr != params.end() )
{
Utils::splitString( mdtacgi, itr->second, "," );
if( plgr.size() != mdtacgi.size() ) return nullptr;
}
itr = params.find( "xrdec.cosc" );
if( itr == params.end() ) return nullptr;
std::string cosc_str = itr->second;
if( cosc_str != "true" && cosc_str != "false" ) return nullptr;
bool cosc = cosc_str == "true";
std::string ckstype;
itr = params.find( "xrdec.cksum" );
if( cosc && itr == params.end() ) return nullptr;
if( cosc )
ckstype = itr->second;
std::string chdigest;
itr = params.find( "xrdec.chdigest" );
if( itr == params.end() )
chdigest = "crc32c";
else
chdigest = itr->second;
bool usecrc32c = ( chdigest == "crc32c" );
bool nomtfile = false;
itr = params.find( "xrdec.nomtfile" );
if( itr != params.end() )
nomtfile = ( itr->second == "true" );
XrdEc::ObjCfg *objcfg = new XrdEc::ObjCfg( objid, nbdta, nbprt, blksz / nbdta, usecrc32c );
objcfg->plgr = std::move( plgr );
objcfg->dtacgi = std::move( dtacgi );
objcfg->mdtacgi = std::move( mdtacgi );
objcfg->nomtfile = nomtfile;
std::unique_ptr<CheckSumHelper> cksHelper( cosc ? new CheckSumHelper( "", ckstype ) : nullptr );
if( cksHelper )
{
auto st = cksHelper->Initialize();
if( !st.IsOK() ) return nullptr;
}
return new EcHandler( headnode, objcfg, std::move( cksHelper ) );
}
XrdCl::CheckSumHelper
Check sum helper for stdio.
Definition XrdClCheckSumHelper.hh:26
XrdCl::EcHandler
Definition XrdClEcHandler.hh:128
XrdCl::URL::ParamsMap
std::map< std::string, std::string > ParamsMap
Definition XrdClURL.hh:33
XrdCl::URL::GetParams
const ParamsMap & GetParams() const
Get the URL params.
Definition XrdClURL.hh:244
XrdCl::Utils::splitString
static void splitString(Container &result, const std::string &input, const std::string &delimiter)
Split a string.
Definition XrdClUtils.hh:56
XrdEc::ObjCfg::mdtacgi
std::vector< std::string > mdtacgi
Definition XrdEcObjCfg.hh:94
XrdEc::ObjCfg::plgr
std::vector< std::string > plgr
Definition XrdEcObjCfg.hh:92
XrdEc::ObjCfg::nomtfile
bool nomtfile
Definition XrdEcObjCfg.hh:98
XrdEc::ObjCfg::dtacgi
std::vector< std::string > dtacgi
Definition XrdEcObjCfg.hh:93

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

Here is the call graph for this function:

## GetResponse() [1/2]

template<typename Response>

Response * XrdCl::GetResponse | ( | AnyObject * | rsp | ) |

inline

Unpack response

Parameters

  rsp | : AnyObject holding response

Returns
  : the response

Definition at line 137 of file XrdClOperationHandlers.hh.

{
Response *ret = nullptr;
rsp->Get( ret );
return ret;
}
XrdCl::AnyObject::Get
void Get(Type &object)
Retrieve the object being held.
Definition XrdClAnyObject.hh:78

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 152 of file XrdClOperationHandlers.hh.

{
if( !status->IsOK() ) return &NullRef<Response>::value;
return GetResponse<Response>( rsp );
}
XrdCl::GetResponse
Response * GetResponse(AnyObject *rsp)
Definition XrdClOperationHandlers.hh:137
XrdCl::NullRef::value
static Response value
Definition XrdClOperationHandlers.hh:121

References GetResponse(), XrdCl::Status::IsOK(), and XrdCl::NullRef< Response >::value.

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.

{
return GetXAttrImpl<false>( std::move( file ), std::move( name ) );
}
XrdCl::GetXAttrImpl
GetXAttr operation (.
Definition XrdClFileOperations.hh:1088

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

{
return GetXAttrBulkImpl<false>( std::move( file ), std::move( attrs ) );
}
XrdCl::GetXAttrBulkImpl
GetXAttr bulk operation (.
Definition XrdClFileOperations.hh:1150

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

{
return GetXAttrFsImpl<false>( std::move( fs ), std::move( path ), std::move( name ) );
}
XrdCl::GetXAttrFsImpl
GetXAttr operation (.
Definition XrdClFileSystemOperations.hh:973

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

{
return GetXAttrFsBulkImpl<false>( std::move( fs ), std::move( path ), std::move( attrs ) );
}
XrdCl::GetXAttrFsBulkImpl
GetXAttr bulk operation (.
Definition XrdClFileSystemOperations.hh:1035

## InitTLS()

bool XrdCl::InitTLS | ( |  | ) |

Initialize TLS context, returns false on failure

Definition at line 96 of file XrdClTls.cc.

{
static std::mutex tls_mutex;
std::lock_guard<std::mutex> tls_lock(tls_mutex);
if (tlsContext)
return true;
XrdCl::Env *env = XrdCl::DefaultEnv::GetEnv();
XrdCl::Log *log = XrdCl::DefaultEnv::GetLog();
int notls = false;
env->GetInt("NoTlsOK", notls);
if (notls)
return false;
const char *cadir = getenv("X509_CERT_DIR");
const char *cafile = getenv("X509_CERT_FILE");
if (!cadir && !cafile)
cadir = "/etc/grid-security/certificates";
const char *msg;
const mode_t camode = S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
if (cadir && (msg = XrdOucUtils::ValPath(cadir, camode, true))) {
log->Error(XrdCl::TlsMsg, "Failed to initialize TLS context: CA directory %s", msg);
env->PutInt("NoTlsOK", 1);
return false;
}
std::string emsg = "unknown error";
tlsContext = std::make_unique<XrdTlsContext>(nullptr, nullptr, cadir, cafile, 0ul, &emsg);
if (!tlsContext || !tlsContext->isOK()) {
tlsContext.reset(nullptr);
log->Error(XrdCl::TlsMsg, "Failed to initialize TLS context: %s", emsg.c_str());
env->PutInt("NoTlsOK", 1);
return false;
}
return true;
}
tlsContext
static std::unique_ptr< XrdTlsContext > tlsContext
Definition XrdClTls.cc:34
emsg
int emsg(int rc, char *msg)
Definition XrdSectestServer.cc:309
XrdCl::DefaultEnv::GetLog
static Log * GetLog()
Get default log.
Definition XrdClDefaultEnv.cc:493
XrdCl::DefaultEnv::GetEnv
static Env * GetEnv()
Get default client environment.
Definition XrdClDefaultEnv.cc:445
XrdCl::Env
Definition XrdClEnv.hh:38
XrdCl::Env::PutInt
bool PutInt(const std::string &key, int value)
Definition XrdClEnv.cc:110
XrdCl::Env::GetInt
bool GetInt(const std::string &key, int &value)
Definition XrdClEnv.cc:89
XrdCl::Log
Handle diagnostics.
Definition XrdClLog.hh:101
XrdCl::Log::Error
void Error(uint64_t topic, const char *format,...)
Report an error.
Definition XrdClLog.cc:231
XrdOucUtils::ValPath
static const char * ValPath(const char *path, mode_t allow, bool isdir)
Definition XrdOucUtils.cc:1420
XrdCl::TlsMsg
const uint64_t TlsMsg
Definition XrdClConstants.hh:45

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.

{
return ZipListImpl<false>( std::move( zip ) );
}
XrdCl::ZipListImpl
ZipList operation (.
Definition XrdClZipOperations.hh:534

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

{
return ListXAttrImpl<false>( std::move( file ) );
}
XrdCl::ListXAttrImpl
ListXAttr bulk operation (.
Definition XrdClFileOperations.hh:1323

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

{
return ListXAttrFsImpl<false>( std::move( fs ), std::move( path ) );
}
XrdCl::ListXAttrFsImpl
ListXAttr bulk operation (.
Definition XrdClFileSystemOperations.hh:1213

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

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

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

{
return OpenImpl<false>( std::move( file ), std::move( url ), std::move( flags ),
std::move( mode ) ).Timeout( timeout );
}
XrdCl::OpenImpl
Open operation (.
Definition XrdClFileOperations.hh:97

References XrdCl::Access::None, and 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.

{
return OpenArchiveImpl<false>( std::move( zip ), std::move( fn ),
std::move( flags ) ).Timeout( timeout );
}
XrdCl::OpenArchiveImpl
OpenArchive operation (.
Definition XrdClZipOperations.hh:79

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.

{
return OpenFileImpl<false>( std::move( zip ), std::move( fn ), std::move( flags ),
std::move( size ), std::move( crc32 ) ).Timeout( timeout );
}
XrdCl::OpenFileImpl
OpenFile operation (.
Definition XrdClZipOperations.hh:137

References XrdCl::OpenFlags::None, and 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 510 of file XrdClParallelOperation.hh.

{
return ParallelOperation<false>( container );
}
XrdCl::ParallelOperation
Definition XrdClParallelOperation.hh:80

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 573 of file XrdClParallelOperation.hh.

{
constexpr size_t size = sizeof...( operations );
std::vector<Pipeline> v;
v.reserve( size );
PipesToVec( v, operations... );
return Parallel( v );
}
XrdCl::PipesToVec
void PipesToVec(std::vector< Pipeline > &)
Helper function for converting parameter pack into a vector.
Definition XrdClParallelOperation.hh:518
XrdCl::Parallel
ParallelOperation< false > Parallel(Container &&container)
Factory function for creating parallel operation from a vector.
Definition XrdClParallelOperation.hh:510

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.

{
std::unordered_map<File*, action_list> result;
std::unique_ptr<std::ifstream> fin( path.empty() ? nullptr : new std::ifstream( path, std::ifstream::in ) );
std::istream &input = path.empty() ? std::cin : *fin;
std::string line;
std::unordered_map<uint64_t, File*> files;
std::unordered_map<uint64_t, double> last_stop;
std::unordered_map<uint64_t, double> overlaps;
std::unordered_map<uint64_t, double> overlaps_cnt;
t0 = 10e99;
t1 = 0;
while (input.good())
{
std::getline(input, line);
if (line.empty())
continue;
std::vector<std::string> tokens = ToColumns( line );
if (tokens.size() == 6)
tokens.emplace_back();
if (tokens.size() != 7)
{
throw std::invalid_argument("Invalid input file format.");
}
uint64_t id = std::stoull(tokens[0]); // file object ID
std::string action = tokens[1]; // action name (e.g. Open)
double start = std::stod(tokens[2]); // start time
std::string args = tokens[3]; // operation arguments
double stop = std::stod(tokens[4]); // stop time
std::string status = tokens[5]; // operation status
std::string resp = tokens[6]; // server response
if (option_regex.size())
{
for (auto& v : option_regex)
{
std::vector<std::string> tokens;
Utils::splitString(tokens, v, ":=");
std::regex src(tokens[0]);
if (tokens.size() != 2)
{
std::cerr
<< "Error: invalid regex for argument replacement - must be format like <oldstring>:=<newstring>"
<< std::endl;
exit(EINVAL);
}
else
{
// write the results to an output iterator
args = std::regex_replace(args, src, tokens[1]);
}
}
}
if (start < t0)
t0 = start;
if (stop > t1)
t1 = stop;
if (!files.count(id))
{
files[id] = new File(false);
files[id]->SetProperty("BundledClose", "true");
filenames[files[id]] = args;
filenames[files[id]].erase(args.find(";"));
overlaps[id] = 0;
overlaps_cnt[id] = 0;
last_stop[id] = stop;
}
else
{
overlaps_cnt[id]++;
if (start > last_stop[id])
{
overlaps[id]++;
}
last_stop[id] = stop;
}
last_stop[id] = stop;
double nominal_duration = stop - start;
if (status != "[SUCCESS]")
{
responseerrors[files[id]]++;
}
else
{
result[files[id]].emplace(
start, ActionExecutor(*files[id], action, args, status, resp, nominal_duration));
}
}
for (auto& it : overlaps)
{
// compute the synchronicity of requests
synchronicity[files[it.first]] = 100.0 * (it.second / overlaps_cnt[it.first]);
}
return result;
}
File
XrdOucString File
Definition XrdSecpwdSrvAdmin.cc:159
XrdCl::ActionExecutor
Executes an action registered in the csv file.
Definition XrdClReplay.cc:315
XrdCl::ToColumns
std::vector< std::string > ToColumns(const std::string &row)
Split a row into columns.
Definition XrdClReplay.cc:826

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.

{
return PgReadImpl<false>( std::move( file ), std::move( offset ), std::move( size ),
std::move( buffer ) ).Timeout( timeout );
}
XrdCl::PgReadImpl
PgRead operation (.
Definition XrdClFileOperations.hh:286

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.

{
return PgWriteImpl<false>( std::move( file ), std::move( offset ), std::move( size ),
std::move( buffer ), std::move( cksums ) ).Timeout( timeout );
}
XrdCl::PgWriteImpl
PgWrite operation (.
Definition XrdClFileOperations.hh:374

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.

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

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 518 of file XrdClParallelOperation.hh.

{
// base case
}

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 543 of file XrdClParallelOperation.hh.

{
v.emplace_back( operation );
PipesToVec( v, others... );
}

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 551 of file XrdClParallelOperation.hh.

{
v.emplace_back( operation );
PipesToVec( v, others... );
}

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 559 of file XrdClParallelOperation.hh.

{
v.emplace_back( std::move( pipeline ) );
PipesToVec( v, others... );
}

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.

{
PropertyMap::const_iterator it;
it = pProperties.find( name );
if( it == pProperties.end() )
return std::string();
return it->second;
}

References XrdCl::PropertyList::Get().

Here is the call graph for this function:

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

{
PropertyMap::const_iterator it;
it = pProperties.find( name );
if( it == pProperties.end() )
return false;
item = it->second;
return true;
}

References XrdCl::PropertyList::Get().

Here is the call graph for this function:

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

{
std::string tmp;
item.clear();
for( int i = 0; HasProperty( name, i ); ++i )
{
if( !Get( name, i, tmp ) )
return false;
item.push_back( tmp );
}
return true;
}

References XrdCl::PropertyList::Get().

Here is the call graph for this function:

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

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

References XrdCl::PropertyList::Set().

Here is the call graph for this function:

## 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

Referenced by XrdCl::ZipArchive::ReadFromImpl.

Here is the caller graph for this function:

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

{
return Read( std::move( file ), std::move( offset ), std::move( size ),
std::move( buffer ), timeout );
}
XrdCl::Read
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.
Definition XrdClFileOperations.hh:273

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

{
return PgRead( std::move( file ), std::move( offset ), std::move( size ),
std::move( buffer ), timeout );
}
XrdCl::PgRead
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.
Definition XrdClFileOperations.hh:331

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

{
return ReadImpl<false>( std::move( file ), std::move( offset ), std::move( size ),
std::move( buffer ) ).Timeout( timeout );
}
XrdCl::ReadImpl
Read operation (.
Definition XrdClFileOperations.hh:228

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.

{
return ZipReadImpl<false>( std::move( zip ), std::move( offset ), std::move( size ),
std::move( buffer ) ).Timeout( timeout );
}
XrdCl::ZipReadImpl
Read operation (.
Definition XrdClZipOperations.hh:199

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.

{
return ZipReadFromImpl<false>( std::move( zip ), std::move( fn ), std::move( offset ),
std::move( size ), std::move( buffer ) ).Timeout( timeout );
}
XrdCl::ZipReadFromImpl
Read operation (.
Definition XrdClZipOperations.hh:256

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.

{
if( me.openstage != ZipArchive::Done || !me.archive.IsOpen() )
return XRootDStatus( stError, errInvalidOp );
Log *log = DefaultEnv::GetLog();
auto cditr = me.cdmap.find( fn );
if( cditr == me.cdmap.end() )
return XRootDStatus( stError, errNotFound,
errNotFound, "File not found." );
CDFH *cdfh = me.cdvec[cditr->second].get();
// check if the file is compressed, for now we only support uncompressed and inflate/deflate compression
if( cdfh->compressionMethod != 0 && cdfh->compressionMethod != Z_DEFLATED )
return XRootDStatus( stError, errNotSupported,
0, "The compression algorithm is not supported!" );
// Now the problem is that at the beginning of our
// file there is the Local-file-header, which size
// is not known because of the variable size 'extra'
// field, so we need to know the offset of the next
// record and shift it by the file size.
// The next record is either the next LFH (next file)
// or the start of the Central-directory.
uint64_t cdOffset = me.zip64eocd ? me.zip64eocd->cdOffset : me.eocd->cdOffset;
uint64_t nextRecordOffset = ( cditr->second + 1 < me.cdvec.size() ) ?
CDFH::GetOffset( *me.cdvec[cditr->second + 1] ) : cdOffset;
uint64_t filesize = cdfh->compressedSize;
if( filesize == std::numeric_limits<uint32_t>::max() && cdfh->extra )
filesize = cdfh->extra->compressedSize;
uint16_t descsize = cdfh->HasDataDescriptor() ?
DataDescriptor::GetSize( cdfh->IsZIP64() ) : 0;
uint64_t fileoff = nextRecordOffset - filesize - descsize;
uint64_t offset = fileoff + relativeOffset;
uint64_t uncompressedSize = cdfh->uncompressedSize;
if( uncompressedSize == std::numeric_limits<uint32_t>::max() && cdfh->extra )
uncompressedSize = cdfh->extra->uncompressedSize;
uint64_t sizeTillEnd = relativeOffset > uncompressedSize ?
0 : uncompressedSize - relativeOffset;
if( size > sizeTillEnd ) size = sizeTillEnd;
// if it is a compressed file use ZIP cache to read from the file
if( cdfh->compressionMethod == Z_DEFLATED )
{
log->Dump( ZipMsg, "[%p] Reading compressed data.", (void*)&me );
// check if respective ZIP cache exists
bool empty = me.zipcache.find( fn ) == me.zipcache.end();
// if the entry does not exist, it will be created using
// default constructor
ZipCache &cache = me.zipcache[fn];
if( relativeOffset > uncompressedSize )
{
// we are reading past the end of file,
// we can serve the request right away!
RSP *r = new RSP( relativeOffset, 0, usrbuff );
AnyObject *rsp = new AnyObject();
rsp->Set( r );
usrHandler->HandleResponse( new XRootDStatus(), rsp );
return XRootDStatus();
}
uint32_t sizereq = size;
if( relativeOffset + size > uncompressedSize )
sizereq = uncompressedSize - relativeOffset;
cache.QueueReq( relativeOffset, sizereq, usrbuff, usrHandler );
// if we have the whole ZIP archive we can populate the cache
// straight away
if( empty && me.buffer)
{
auto begin = me.buffer.get() + fileoff;
auto end = begin + filesize ;
buffer_t buff( begin, end );
cache.QueueRsp( XRootDStatus(), 0, std::move( buff ) );
return XRootDStatus();
}
// if we don't have the data we need to issue a remote read
if( !me.buffer )
{
if( relativeOffset > filesize ) return XRootDStatus(); // there's nothing to do,
// we already have all the data locally
uint32_t rdsize = size;
// check if this is the last read (we reached the end of
// file from user perspective)
if( relativeOffset + size >= uncompressedSize )
{
// if yes, make sure we readout all the compressed data
// Note: In a patological case the compressed size may
// be greater than the uncompressed size
rdsize = filesize > relativeOffset ?
filesize - relativeOffset :
0;
}
// make sure we are not reading past the end of
// compressed data
if( relativeOffset + size > filesize )
rdsize = filesize - relativeOffset;
// now read the data ...
auto rdbuff = std::make_shared<ZipCache::buffer_t>( rdsize );
Pipeline p = XrdCl::RdWithRsp<RSP>( me.archive, offset, rdbuff->size(), rdbuff->data() ) >>
[relativeOffset, rdbuff, &cache, &me]( XRootDStatus &st, RSP &rsp )
{
Log *log = DefaultEnv::GetLog();
log->Dump( ZipMsg, "[%p] Read %u bytes of remote data at offset %llu.",
(void*)&me, rsp.GetLength(), (unsigned long long) rsp.GetOffset() );
cache.QueueRsp( st, relativeOffset, std::move( *rdbuff ) );
};
Async( std::move( p ), timeout );
}
return XRootDStatus();
}
// check if we have the whole file in our local buffer
if( me.buffer || size == 0 )
{
if( size )
{
memcpy( usrbuff, me.buffer.get() + offset, size );
log->Dump( ZipMsg, "[%p] Serving read from local cache.", (void*)&me );
}
if( usrHandler )
{
XRootDStatus *st = ZipArchive::make_status();
RSP *rsp = new RSP( relativeOffset, size, usrbuff );
ZipArchive::Schedule( usrHandler, st, rsp );
}
return XRootDStatus();
}
Pipeline p = XrdCl::RdWithRsp<RSP>( me.archive, offset, size, usrbuff ) >>
[=, &me]( XRootDStatus &st, RSP &r )
{
log->Dump( ZipMsg, "[%p] Read %u bytes of remote data at "
"offset %llu.", (void*)&me, r.GetLength(), (unsigned long long) r.GetOffset() );
if( usrHandler )
{
XRootDStatus *status = ZipArchive::make_status( st );
RSP *rsp = nullptr;
if( st.IsOK() )
rsp = new RSP( relativeOffset, r.GetLength(), r.GetBuffer() );
usrHandler->HandleResponse( status, ZipArchive::PkgRsp( rsp ) );
}
};
Async( std::move( p ), timeout );
return XRootDStatus();
}
XrdCl::AnyObject
Definition XrdClAnyObject.hh:33
XrdCl::AnyObject::Set
void Set(Type object, bool own=true)
Definition XrdClAnyObject.hh:59
XrdCl::File::IsOpen
bool IsOpen() const
Check if the file is open.
Definition XrdClFile.cc:846
XrdCl::Log::Dump
void Dump(uint64_t topic, const char *format,...)
Print a dump message.
Definition XrdClLog.cc:299
XrdCl::Pipeline
Definition XrdClOperations.hh:291
XrdCl::ResponseHandler::HandleResponse
virtual void HandleResponse(XRootDStatus *status, AnyObject *response)
Definition XrdClXRootDResponses.hh:1156
XrdCl::ZipCache
Utility class for inflating a compressed buffer.
Definition XrdClZipCache.hh:55
XrdCl::ZipCache::QueueRsp
void QueueRsp(const XRootDStatus &st, uint64_t offset, buffer_t &&buffer)
Definition XrdClZipCache.hh:106
XrdCl::ZipCache::QueueReq
void QueueReq(uint64_t offset, uint32_t length, void *buffer, ResponseHandler *handler)
Definition XrdClZipCache.hh:99
XrdCl::stError
const uint16_t stError
An error occurred that could potentially be retried.
Definition XrdClStatus.hh:32
XrdCl::errNotFound
const uint16_t errNotFound
Definition XrdClStatus.hh:100
XrdCl::ZipMsg
const uint64_t ZipMsg
Definition XrdClConstants.hh:46
XrdCl::errInvalidOp
const uint16_t errInvalidOp
Definition XrdClStatus.hh:51
XrdCl::RdWithRsp
ReadTrait< RSP >::RET RdWithRsp(Ctx< File > file, Arg< uint64_t > offset, Arg< uint32_t > size, Arg< void * > buffer, uint16_t timeout=0)
XrdCl::errNotSupported
const uint16_t errNotSupported
Definition XrdClStatus.hh:62
XrdCl::Async
std::future< XRootDStatus > Async(Pipeline pipeline, uint16_t timeout=0)
Definition XrdClOperations.hh:488
XrdZip::CDFH
Definition XrdZipCDFH.hh:67
XrdZip::CDFH::uncompressedSize
uint32_t uncompressedSize
Definition XrdZipCDFH.hh:336
XrdZip::CDFH::GetOffset
static uint64_t GetOffset(const CDFH &cdfh)
Definition XrdZipCDFH.hh:227
XrdZip::CDFH::extra
std::unique_ptr< Extra > extra
Definition XrdZipCDFH.hh:345
XrdZip::CDFH::compressionMethod
uint16_t compressionMethod
Definition XrdZipCDFH.hh:332
XrdZip::CDFH::HasDataDescriptor
bool HasDataDescriptor()
Definition XrdZipCDFH.hh:324
XrdZip::CDFH::compressedSize
uint32_t compressedSize
Definition XrdZipCDFH.hh:335
XrdZip::CDFH::IsZIP64
bool IsZIP64() const
Definition XrdZipCDFH.hh:316
XrdZip::DataDescriptor::GetSize
static uint8_t GetSize(bool zip64)
Definition XrdZipDataDescriptor.hh:37

## SetUpLogging()

void XrdCl::SetUpLogging | ( | Log * | logger | ) |

Definition at line 15 of file XrdClHttpPlugInUtil.cc.

{
// Assert that there is no existing topic
std::call_once(logging_topic_init, [logger] {
if (logger) {
logger->SetTopicName(kLogXrdClHttp, "XrdClHttp");
}
});
}
logging_topic_init
static std::once_flag logging_topic_init
Definition XrdClHttpPlugInUtil.cc:11
XrdCl::Log::SetTopicName
void SetTopicName(uint64_t topic, std::string name)
Map a topic number to a string.
Definition XrdClLog.cc:163
XrdCl::kLogXrdClHttp
static const uint64_t kLogXrdClHttp
Definition XrdClHttpPlugInUtil.hh:16

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.

{
return SetXAttrImpl<false>( std::move( file ), std::move( name ), std::move( value ) );
}
XrdCl::SetXAttrImpl
SetXAttr operation (.
Definition XrdClFileOperations.hh:969
XrdCl::value
Response NullRef< Response >::value
Definition XrdClOperationHandlers.hh:128

References NullRef< Response >::value.

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

{
return SetXAttrBulkImpl<false>( std::move( file ), std::move( attrs ) );
}
XrdCl::SetXAttrBulkImpl
SetXAttr bulk operation (.
Definition XrdClFileOperations.hh:1032

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

{
return SetXAttrFsImpl<false>( std::move( fs ), std::move( path ), std::move( name ),
std::move( value ) );
}
XrdCl::SetXAttrFsImpl
SetXAttr operation (.
Definition XrdClFileSystemOperations.hh:851

References NullRef< Response >::value.

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

{
return SetXAttrFsBulkImpl<false>( std::move( fs ), std::move( path ), std::move( attrs ) );
}
XrdCl::SetXAttrFsBulkImpl
SetXAttr bulk operation (.
Definition XrdClFileSystemOperations.hh:917

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

{
return StatImpl<false>( std::move( file ), std::move( force ) ).Timeout( timeout );
}
XrdCl::StatImpl
Stat operation (.
Definition XrdClFileOperations.hh:492

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.

{
return StatFsImpl<false>( std::move( fs ), std::move( path ) );
}
XrdCl::StatFsImpl
Stat operation (.
Definition XrdClFileSystemOperations.hh:568

## Stat() [3/3]

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

inline

Factory for creating ZipStatImpl objects.

Definition at line 523 of file XrdClZipOperations.hh.

{
return ZipStatImpl<false>( std::move( zip ) );
}
XrdCl::ZipStatImpl
ZipStat operation (.
Definition XrdClZipOperations.hh:483

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

{
return SyncImpl<false>( std::move( file ) ).Timeout( timeout );
}
XrdCl::SyncImpl
Sync operation (.
Definition XrdClFileOperations.hh:603

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.

{
T* object;
any.Get( object );
return *object;
}

References XrdCl::AnyObject::Get().

Here is the call graph for this function:

## to_lower()

std::string XrdCl::to_lower | ( | std::string | str | ) |

inline static

Definition at line 116 of file XrdClConstants.hh.

{
std::transform( str.begin(), str.end(), str.begin(), ::tolower );
return str;
}

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

{
std::vector<std::string> columns;
size_t quotecnt = 0;
size_t pos = 0;
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
while( pos != std::string::npos && pos < row.size() )
{
if( row[pos] == '"' ) // we are handling a quoted column
{
if( quotecnt > 0 ) // this is a closing quote
{
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
throw std::runtime_error( "Parsing error: missing comma" );
--quotecnt; // strip the quote
++pos; // move to the comma or end of row
continue;
}
else // this is a opening quote
{
++quotecnt;
auto b = std::next( row.begin(), pos + 1 ); // iterator to the beginning of our column
size_t posend = row.find( "\",", pos + 1 ); // position of the cursor to the end of our column
if( posend == std::string::npos && row[row.size() - 1] == '"' )
posend = row.size() - 1;
else if( posend == std::string::npos )
throw std::runtime_error( "Parsing error: missing closing quote" );
auto e = std::next( row.begin(), posend ); // iterator to the end of our column
columns.emplace_back( b, e ); // add the column to the result
pos = posend; // move to the next column
continue;
}
}
else if( row[pos] == ',' ) // we are handling a column separator
{
if( pos + 1 < row.size() && row[pos + 1] == '"' ) // check if the column is quoted
{
++pos; // if yes we will handle this with the logic reserved for quoted columns
continue;
}
auto b = std::next( row.begin(), pos + 1 ); // iterator to the beginning of our column
size_t posend = row.find( ',', pos + 1 ); // position of the cursor to the end of our column
if( posend == std::string::npos )
posend = row.size();
auto e = std::next( row.begin(), posend ); // iterator to the end of our column
columns.emplace_back( b, e ); // add the column to the result
pos = posend; // move to the next column
continue;
}
else if( pos == 0 ) // we are handling the 1st column if not quoted
{
size_t posend = row.find( ',', pos + 1 ); // position of the cursor to the end of our column
if( posend == std::string::npos )
posend = row.size();
auto end = std::next( row.begin(), posend ); // iterator to the end of our column
columns.emplace_back( row.begin(), end ); // add the column to the result
pos = posend; // move to the next column
continue;
}
else
{
throw std::runtime_error( "Parsing error: invalid input file." );
}
}
return columns;
}

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.

{
return TruncateImpl<false>( std::move( file ), std::move( size ) ).Timeout( timeout );
}
XrdCl::TruncateImpl
Truncate operation (.
Definition XrdClFileOperations.hh:649

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.

{
return TruncateFsImpl<false>( std::move( fs ), std::move( path ), std::move( size ) );
}
XrdCl::TruncateFsImpl
Truncate operation (.
Definition XrdClFileSystemOperations.hh:288

## tuple_call_impl()

template<typename FUNC, typename TUPL, int ... INDICES>

auto XrdCl::tuple_call_impl | ( | FUNC & | func,
|  | TUPL & | args,
|  | sequence< INDICES... > | )->decltype(func(std::move(std::get< INDICES >(args))...))

inline static

Definition at line 49 of file XrdClApply.hh.

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

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

{
return VectorReadImpl<false>( std::move( file ), std::move( chunks ), std::move( buffer ) ).Timeout( timeout );
}
XrdCl::VectorReadImpl
VectorRead operation (.
Definition XrdClFileOperations.hh:703

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.

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

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.

{
return VectorWriteImpl<false>( std::move( file ), std::move( chunks ) ).Timeout( timeout );
}
XrdCl::VectorWriteImpl
VectorWrite operation (.
Definition XrdClFileOperations.hh:765

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 503 of file XrdClOperations.hh.

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

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.

{
return WriteImpl<false>( std::move( file ), std::move( offset ), std::move( size ),
std::move( buffer ) ).Timeout( timeout );
}
XrdCl::WriteImpl
Write operation (.
Definition XrdClFileOperations.hh:546

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.

{
return ZipWriteImpl<false>( std::move( zip ), std::move( size ),
std::move( buffer ) ).Timeout( timeout );
}
XrdCl::ZipWriteImpl
Write operation (.
Definition XrdClZipOperations.hh:317

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.

{
return WriteVImpl<false>( std::move( file ), std::move( offset ),
std::move( iov ) ).Timeout( timeout );
}
XrdCl::WriteVImpl
WriteV operation (.
Definition XrdClFileOperations.hh:819

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

Here is the call graph for this function:

## Variable Documentation

## AppMsg

const uint64_t XrdCl::AppMsg = 0x0000000000000001ULL

Definition at line 32 of file XrdClConstants.hh.

Referenced by XrdCl::FSExecutor::AddCommand(), DoCache(), DoCat(), DoCD(), DoChMod(), DoLocate(), DoLS(), DoMkDir(), DoMv(), DoPrepare(), DoQuery(), DoRm(), DoRmDir(), DoSpaceInfo(), DoStat(), DoStatVFS(), DoTail(), DoTruncate(), DoXAttr(), XrdCl::ActionExecutor::Execute(), XrdCl::FSExecutor::Execute(), IndexRemote(), main(), and ProcessStatQuery().

## AsyncSockMsg

const uint64_t XrdCl::AsyncSockMsg = 0x0000000000000200ULL

Definition at line 41 of file XrdClConstants.hh.

Referenced by XrdCl::AsyncSocketHandler::CheckHSWait(), XrdCl::AsyncSocketHandler::Close(), XrdCl::AsyncSocketHandler::Connect(), XrdCl::AsyncSocketHandler::DoTlsHandShake(), XrdCl::AsyncSocketHandler::HandleHandShake(), XrdCl::AsyncSocketHandler::OnConnectionReturn(), XrdCl::AsyncSocketHandler::OnFault(), XrdCl::AsyncSocketHandler::OnFaultWhileHandshaking(), XrdCl::AsyncHSReader::Read(), XrdCl::AsyncMsgReader::Read(), XrdCl::Socket::Send(), XrdCl::AsyncHSWriter::Write(), and XrdCl::AsyncMsgWriter::Write().

## 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

Definition at line 61 of file XrdClConstants.hh.

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

## DefaultCPInitTimeout

const int XrdCl::DefaultCPInitTimeout = 600

Definition at line 65 of file XrdClConstants.hh.

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

## DefaultCPParallelChunks

const int XrdCl::DefaultCPParallelChunks = 4

Definition at line 62 of file XrdClConstants.hh.

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

## DefaultCpRetry

const int XrdCl::DefaultCpRetry = 0

Definition at line 97 of file XrdClConstants.hh.

## DefaultCpRetryPolicy

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

Definition at line 114 of file XrdClConstants.hh.

## DefaultCpTarget

const char* const XrdCl::DefaultCpTarget = ""

Definition at line 113 of file XrdClConstants.hh.

## DefaultCPTimeout

const int XrdCl::DefaultCPTimeout = 0

Definition at line 67 of file XrdClConstants.hh.

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

## DefaultCPTPCTimeout

const int XrdCl::DefaultCPTPCTimeout = 1800

Definition at line 66 of file XrdClConstants.hh.

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

## DefaultCpUsePgWrtRd

const int XrdCl::DefaultCpUsePgWrtRd = 1

Definition at line 98 of file XrdClConstants.hh.

## DefaultDataServerTTL

const int XrdCl::DefaultDataServerTTL = 300

Definition at line 63 of file XrdClConstants.hh.

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

## DefaultGlfnRedirector

const char* const XrdCl::DefaultGlfnRedirector = ""

Definition at line 109 of file XrdClConstants.hh.

## DefaultIPNoShuffle

const int XrdCl::DefaultIPNoShuffle = 0

Definition at line 94 of file XrdClConstants.hh.

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

## DefaultLoadBalancerTTL

const int XrdCl::DefaultLoadBalancerTTL = 1200

Definition at line 64 of file XrdClConstants.hh.

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

## DefaultLocalMetalinkFile

const int XrdCl::DefaultLocalMetalinkFile = 0

Definition at line 75 of file XrdClConstants.hh.

## DefaultMaxMetalinkWait

const int XrdCl::DefaultMaxMetalinkWait = 60

Definition at line 86 of file XrdClConstants.hh.

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

## DefaultMetalinkProcessing

const int XrdCl::DefaultMetalinkProcessing = 1

Definition at line 74 of file XrdClConstants.hh.

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

## DefaultMultiProtocol

const int XrdCl::DefaultMultiProtocol = 0

Definition at line 72 of file XrdClConstants.hh.

## DefaultNetworkStack

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

Definition at line 101 of file XrdClConstants.hh.

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

## DefaultNoDelay

const int XrdCl::DefaultNoDelay = 1

Definition at line 82 of file XrdClConstants.hh.

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

## DefaultNotAuthorizedRetryLimit

const int XrdCl::DefaultNotAuthorizedRetryLimit = 3

Definition at line 88 of file XrdClConstants.hh.

## DefaultNoTlsOK

const int XrdCl::DefaultNoTlsOK = 0

Definition at line 90 of file XrdClConstants.hh.

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

## DefaultOpenRecovery

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

Definition at line 108 of file XrdClConstants.hh.

## DefaultParallelEvtLoop

const int XrdCl::DefaultParallelEvtLoop = 10

Definition at line 73 of file XrdClConstants.hh.

## DefaultPlugIn

const char* const XrdCl::DefaultPlugIn = ""

Definition at line 105 of file XrdClConstants.hh.

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

## DefaultPlugInConfDir

const char* const XrdCl::DefaultPlugInConfDir = ""

Definition at line 104 of file XrdClConstants.hh.

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

## DefaultPollerPreference

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

Definition at line 100 of file XrdClConstants.hh.

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

## DefaultPreferIPv4

const int XrdCl::DefaultPreferIPv4 = 0

Definition at line 85 of file XrdClConstants.hh.

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

## DefaultPreserveLocateTried

const int XrdCl::DefaultPreserveLocateTried = 1

Definition at line 87 of file XrdClConstants.hh.

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

## DefaultPreserveXAttrs

const int XrdCl::DefaultPreserveXAttrs = 0

Definition at line 89 of file XrdClConstants.hh.

Referenced by main().

## DefaultReadRecovery

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

Definition at line 106 of file XrdClConstants.hh.

## DefaultRedirectLimit

const int XrdCl::DefaultRedirectLimit = 16

Definition at line 59 of file XrdClConstants.hh.

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

## DefaultRequestTimeout

const int XrdCl::DefaultRequestTimeout = 1800

Definition at line 54 of file XrdClConstants.hh.

Referenced by XrdCl::ZipListHandler::ZipListHandler(), XrdCl::FileStateHandler::PgWrite(), and XrdCl::MessageUtils::ProcessSendParams().

## DefaultRetryWrtAtLBLimit

const int XrdCl::DefaultRetryWrtAtLBLimit = 3

Definition at line 96 of file XrdClConstants.hh.

## DefaultRunForkHandler

const int XrdCl::DefaultRunForkHandler = 1

Definition at line 58 of file XrdClConstants.hh.

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

## DefaultStreamErrorWindow

const int XrdCl::DefaultStreamErrorWindow = 1800

Definition at line 57 of file XrdClConstants.hh.

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

## DefaultStreamTimeout

const int XrdCl::DefaultStreamTimeout = 60

Definition at line 55 of file XrdClConstants.hh.

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

## DefaultSubStreamsPerChannel

const int XrdCl::DefaultSubStreamsPerChannel = 1

Definition at line 51 of file XrdClConstants.hh.

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

## DefaultTCPKeepAlive

const int XrdCl::DefaultTCPKeepAlive = 0

Definition at line 68 of file XrdClConstants.hh.

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

## DefaultTCPKeepAliveInterval

const int XrdCl::DefaultTCPKeepAliveInterval = 75

Definition at line 70 of file XrdClConstants.hh.

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

## DefaultTCPKeepAliveProbes

const int XrdCl::DefaultTCPKeepAliveProbes = 9

Definition at line 71 of file XrdClConstants.hh.

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

## DefaultTCPKeepAliveTime

const int XrdCl::DefaultTCPKeepAliveTime = 7200

Definition at line 69 of file XrdClConstants.hh.

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

## DefaultTimeoutResolution

const int XrdCl::DefaultTimeoutResolution = 15

Definition at line 56 of file XrdClConstants.hh.

Referenced by XrdCl::AsyncSocketHandler::AsyncSocketHandler(), XrdCl::Channel::Channel(), XrdCl::FileTimer::Run(), and XrdCl::TickGeneratorTask::Run().

## DefaultTlsDbgLvl

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

Definition at line 110 of file XrdClConstants.hh.

## DefaultTlsMetalink

const int XrdCl::DefaultTlsMetalink = 0

Definition at line 92 of file XrdClConstants.hh.

## DefaultTlsNoData

const int XrdCl::DefaultTlsNoData = 0

Definition at line 91 of file XrdClConstants.hh.

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

## DefaultWantTlsOnNoPgrw

const int XrdCl::DefaultWantTlsOnNoPgrw = 0

Definition at line 95 of file XrdClConstants.hh.

## DefaultWorkerThreads

const int XrdCl::DefaultWorkerThreads = 3

Definition at line 60 of file XrdClConstants.hh.

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

## DefaultWriteRecovery

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

Definition at line 107 of file XrdClConstants.hh.

## DefaultXCpBlockSize

const int XrdCl::DefaultXCpBlockSize = 134217728

Definition at line 77 of file XrdClConstants.hh.

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

## DefaultXRateThreshold

const int XrdCl::DefaultXRateThreshold = 0

Definition at line 76 of file XrdClConstants.hh.

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

## DefaultZipMtlnCksum

const int XrdCl::DefaultZipMtlnCksum = 0

Definition at line 93 of file XrdClConstants.hh.

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

## errAuthFailed

const uint16_t XrdCl::errAuthFailed = 204

Definition at line 88 of file XrdClStatus.hh.

## errCheckSumError

const uint16_t XrdCl::errCheckSumError = 305

Definition at line 101 of file XrdClStatus.hh.

Referenced by XrdCl::Utils::GetLocalCheckSum(), XrdCl::Utils::GetRemoteCheckSum(), XrdCl::CheckSumHelper::Initialize(), XrdCl::ClassicCopyJob::Run(), and XrdCl::ThirdPartyCopyJob::Run().

## 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

Definition at line 78 of file XrdClStatus.hh.

Referenced by XrdCl::FileStateHandler::Close(), and XrdCl::AsyncSocketHandler::OnConnectionReturn().

## errCorruptedHeader

const uint16_t XrdCl::errCorruptedHeader = 307

Definition at line 103 of file XrdClStatus.hh.

Referenced by XrdCl::AsyncSocketHandler::OnRead(), XrdCl::AsyncDiscardReader::Read(), XrdCl::AsyncMsgReader::Read(), XrdCl::AsyncRawReader::Read(), and XrdCl::AsyncVectorReader::Read().

## errDataError

const uint16_t XrdCl::errDataError = 14

data is corrupted

Definition at line 63 of file XrdClStatus.hh.

Referenced by XrdEc::block_t::fail_missing(), XrdCl::XRootDTransport::GetMore(), XrdCl::ChunkHandler::HandleResponse(), XrdCl::XRootDMsgHandler::InspectStatusRsp(), XrdCl::ZipArchive::OpenArchive(), XrdCl::FileStateHandler::PgWrite(), XrdEc::block_t::read(), XrdCl::ClassicCopyJob::Run(), XrdCl::XRootDTransport::UnMarchalStatusMore(), and XrdCl::XRootDTransport::UnMarshalStatusBody().

## errErrorResponse

const uint16_t XrdCl::errErrorResponse = 400

Definition at line 105 of file XrdClStatus.hh.

Referenced by Fatal(), XrdSsiUtils::GetErr(), XrdCl::XRootDMsgHandler::Process(), Posix::Rename(), XrdPosixMap::Result(), XrdSsiUtils::SetErr(), and XrdCl::XRootDStatus::ToStr().

## 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

const uint16_t XrdCl::errInternal = 7

Internal error.

Definition at line 56 of file XrdClStatus.hh.

Referenced by Posix::_PRead(), XrdCl::Socket::ClassifyErrno(), Posix::Close(), Posix::DirList(), XrdCl::XRootDTransport::GetHeader(), XrdCl::Utils::GetLocalCheckSum(), XrdCl::Utils::GetRemoteCheckSum(), XrdCl::XRootDTransport::GetSignature(), XrdCl::ChunkHandler::HandleResponse(), XrdCl::FutureWrapper< Response >::HandleResponse(), XrdCl::MetalinkReadHandler::HandleResponse(), XrdCl::MetalinkOpenHandler::HandleResponseWithHosts(), XrdCl::XRootDTransport::HandShake(), XrdCl::CheckSumHelper::Initialize(), XrdCl::XCpCtx::Initialize(), Posix::MkDir(), XrdCl::AsyncSocketHandler::OnRead(), XrdCl::AsyncSocketHandler::OnReadWhileHandshaking(), XrdCl::AsyncSocketHandler::OnWrite(), Posix::PReadVec(), Posix::PWrite(), XrdCl::XRootDTransport::Query(), XrdCl::AsyncRawReader::Read(), XrdCl::AsyncVectorReader::Read(), XrdCl::EcHandler::Read(), Posix::Rename(), Posix::RmDir(), XrdCl::Operation< HasHndl >::Run(), XrdCl::AsyncSocketHandler::SendHSMsg(), Posix::Unlink(), XrdCl::MessageUtils::WaitForResponse(), XrdCl::EcHandler::Write(), XrdCl::FileStateHandler::Write(), XrdCl::FileStateHandler::Write(), and XrdCl::XRootDMsgHandler::WriteMessageBody().

## 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

const uint16_t XrdCl::errInvalidArgs = 9

Definition at line 58 of file XrdClStatus.hh.

Referenced by XrdCl::CopyProcess::AddJob(), BuildPath(), XrdCl::Socket::ClassifyErrno(), ConvertMode(), XrdCl::MessageUtils::CreateXAttrVec(), XrdCl::MessageUtils::CreateXAttrVec(), DoCache(), DoCat(), DoCD(), DoChMod(), DoLocate(), DoLS(), DoMkDir(), DoMv(), DoPrepare(), DoQuery(), DoRm(), DoRmDir(), DoSpaceInfo(), DoStat(), DoStatVFS(), DoTail(), DoTruncate(), DoXAttr(), XrdCl::CheckSumHelper::GetRawCheckSum(), XrdCl::FileStateHandler::Open(), XrdCl::FileStateHandler::PgReadRetry(), XrdCl::EcHandler::PgWrite(), XrdCl::FileStateHandler::PgWrite(), XrdCl::CopyProcess::Prepare(), ProcessStatQuery(), XrdCl::ClassicCopyJob::Run(), and XrdEc::Reader::VectorRead().

## errInvalidMessage

const uint16_t XrdCl::errInvalidMessage = 201

Definition at line 85 of file XrdClStatus.hh.

Referenced by XrdCl::XRootDTransport::GetMore(), XrdCl::XRootDMsgHandler::Process(), XrdCl::XRootDTransport::UnMarchalStatusMore(), XrdCl::XRootDTransport::UnMarshallBody(), and XrdCl::XRootDTransport::UnMarshalStatusBody().

## 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(), main(), 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::ZipArchive::ReadFromImpl, 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

const uint16_t XrdCl::errInvalidResponse = 303

Definition at line 99 of file XrdClStatus.hh.

Referenced by XrdCl::Utils::GetRemoteCheckSum(), XrdCl::AsyncDiscardReader::GetResponse(), XrdCl::AsyncRawReader::GetResponse(), XrdCl::AsyncVectorReader::GetResponse(), XrdCl::FileSystemUtils::GetSpaceInfo(), and XrdCl::XRootDMsgHandler::Process().

## 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

const uint16_t XrdCl::errLocalError = 402

Definition at line 107 of file XrdClStatus.hh.

Referenced by XrdCl::LocalFileHandler::Close(), XrdCl::LocalFileHandler::DelXAttr(), XrdCl::LocalFileHandler::GetXAttr(), XrdCl::LocalFileHandler::ListXAttr(), XrdCl::LocalFileHandler::MkdirPath(), XrdCl::LocalFileHandler::Open(), XrdCl::LocalFileHandler::Read(), XrdCl::LocalFileHandler::ReadV(), XrdCl::LocalFileHandler::SetXAttr(), XrdCl::LocalFileHandler::Stat(), XrdCl::LocalFileHandler::Sync(), XrdCl::LocalFileHandler::Truncate(), XrdCl::LocalFileHandler::VectorRead(), XrdCl::LocalFileHandler::VectorWrite(), XrdCl::LocalFileHandler::Write(), and XrdCl::LocalFileHandler::WriteV().

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

Referenced by XrdCl::Status::Status().

## errNotFound

const uint16_t XrdCl::errNotFound = 304

Definition at line 100 of file XrdClStatus.hh.

Referenced by XrdCl::FileSystem::DirList(), XrdCl::ZipArchive::GetCRC32(), XrdCl::ZipArchive::GetOffset(), XrdCl::ZipArchive::OpenFile(), XrdCl::ZipArchive::ReadFromImpl, and XrdCl::ZipArchive::Stat().

## errNotImplemented

const uint16_t XrdCl::errNotImplemented = 15

Operation is not implemented.

Definition at line 64 of file XrdClStatus.hh.

Referenced by XrdCl::FileSystemPlugIn::ChMod(), XrdCl::FilePlugIn::Close(), XrdCl::FileSystemPlugIn::DeepLocate(), XrdCl::FileSystemPlugIn::DelXAttr(), XrdCl::FileSystemPlugIn::DirList(), XrdCl::FilePlugIn::Fcntl(), XrdCl::FileSystemPlugIn::GetXAttr(), XrdCl::FileSystemPlugIn::ListXAttr(), XrdCl::FileSystemPlugIn::Locate(), XrdCl::FileSystemPlugIn::MkDir(), XrdCl::FileSystemPlugIn::Mv(), XrdCl::FilePlugIn::Open(), XrdCl::FilePlugIn::PgRead(), XrdCl::FilePlugIn::PgWrite(), XrdCl::FileSystemPlugIn::Ping(), XrdCl::FileSystemPlugIn::Prepare(), XrdCl::FileSystemPlugIn::Protocol(), XrdCl::FileSystemPlugIn::Query(), XrdCl::FilePlugIn::Read(), XrdCl::FilePlugIn::Read(), XrdCl::FileSystemPlugIn::Rm(), XrdCl::FileSystemPlugIn::RmDir(), XrdCl::FileSystemPlugIn::SendInfo(), XrdCl::FileSystemPlugIn::SetXAttr(), XrdCl::FilePlugIn::Stat(), XrdCl::FileSystemPlugIn::Stat(), XrdCl::FileSystemPlugIn::StatVFS(), XrdCl::FilePlugIn::Sync(), XrdCl::FilePlugIn::Truncate(), XrdCl::FileSystemPlugIn::Truncate(), XrdCl::FilePlugIn::VectorRead(), XrdCl::FilePlugIn::VectorWrite(), XrdCl::FilePlugIn::Visa(), XrdCl::FilePlugIn::Write(), XrdCl::FilePlugIn::Write(), XrdCl::FilePlugIn::Write(), and XrdCl::FilePlugIn::WriteV().

## errNotSupported

const uint16_t XrdCl::errNotSupported = 13

Definition at line 62 of file XrdClStatus.hh.

Referenced by XrdCl::Utils::CheckTPC(), XrdCl::Utils::CheckTPCLite(), XrdCl::EcHandler::Close(), XrdCl::File::DelXAttr(), XrdCl::FileSystem::DelXAttr(), XrdCl::FileSystem::DirList(), XrdCl::LocalFileHandler::ExecRequest(), XrdCl::LocalFileHandler::Fcntl(), XrdCl::ZipArchive::GetOffset(), XrdCl::File::GetXAttr(), XrdCl::FileSystem::GetXAttr(), XrdCl::File::ListXAttr(), XrdCl::FileSystem::ListXAttr(), XrdCl::EcHandler::Open(), XrdCl::PostMaster::QueryTransport(), XrdCl::ZipArchive::ReadFromImpl, XrdCl::PostMaster::RegisterEventHandler(), XrdCl::PostMaster::RemoveEventHandler(), XrdCl::TPFallBackCopyJob::Run(), XrdCl::PostMaster::Send(), XrdCl::Socket::Send(), XrdCl::File::SetXAttr(), XrdCl::FileSystem::SetXAttr(), XrdCl::XRootDTransport::UnMarchalStatusMore(), XrdCl::LocalFileHandler::Visa(), and XrdCl::EcHandler::Write().

## errOperationExpired

const uint16_t XrdCl::errOperationExpired = 206

Definition at line 90 of file XrdClStatus.hh.

Referenced by XrdCl::ZipListHandler::HandleResponse(), XrdCl::FileStateHandler::PgWrite(), XrdCl::XRootDMsgHandler::Process(), XrdCl::InQueue::ReportTimeout(), XrdCl::ClassicCopyJob::Run(), XrdCl::Operation< HasHndl >::Run(), XrdCl::TPFallBackCopyJob::Run(), XrdCl::Stream::Tick(), and XrdCl::FileStateHandler::TimeOutRequests().

## 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

Definition at line 61 of file XrdClStatus.hh.

Referenced by XrdCl::Utils::GetDirectoryEntries(), XrdCl::Utils::ProcessConfig(), XrdCl::CopyProcess::Run(), and XrdCl::LocalFileHandler::Sync().

## 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

const uint16_t XrdCl::errPollerError = 105

Definition at line 75 of file XrdClStatus.hh.

Referenced by XrdCl::FileStateHandler::Close(), XrdCl::AsyncSocketHandler::Connect(), XrdCl::AsyncSocketHandler::DisableUplink(), XrdCl::AsyncSocketHandler::EnableUplink(), and XrdCl::AsyncSocketHandler::OnConnectionReturn().

## 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

Definition at line 106 of file XrdClStatus.hh.

Referenced by XrdCl::FileStateHandler::OnStateError(), and XrdCl::XRootDMsgHandler::Process().

## 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

Definition at line 74 of file XrdClStatus.hh.

Referenced by XrdCl::FileStateHandler::Close(), XrdCl::Socket::Poll(), and XrdCl::Socket::ReadRaw().

## errSocketError

const uint16_t XrdCl::errSocketError = 102

Definition at line 72 of file XrdClStatus.hh.

Referenced by XrdCl::Socket::ClassifyErrno(), XrdCl::FileStateHandler::Close(), XrdCl::Socket::ConnectToAddress(), XrdCl::Socket::GetFlags(), XrdCl::Socket::Initialize(), XrdCl::AsyncSocketHandler::OnHeaderCorruption(), XrdCl::Socket::Poll(), XrdCl::Socket::Read(), XrdCl::Socket::ReadRaw(), XrdCl::Socket::ReadV(), XrdCl::Socket::SetFlags(), and XrdCl::Socket::WriteRaw().

## errSocketOptError

const uint16_t XrdCl::errSocketOptError = 106

Definition at line 76 of file XrdClStatus.hh.

Referenced by XrdCl::FileStateHandler::Close(), XrdCl::Socket::Cork(), XrdCl::Socket::GetSockOpt(), XrdCl::AsyncSocketHandler::OnConnectionReturn(), XrdCl::Socket::SetSockOpt(), and XrdCl::Socket::Uncork().

## errSocketTimeout

const uint16_t XrdCl::errSocketTimeout = 103

Definition at line 73 of file XrdClStatus.hh.

Referenced by XrdCl::Socket::ConnectToAddress(), XrdCl::AsyncSocketHandler::HandleHandShake(), XrdCl::XRootDTransport::IsStreamBroken(), XrdCl::AsyncSocketHandler::OnTimeoutWhileHandshaking(), XrdCl::Socket::Poll(), XrdCl::Socket::ReadRaw(), and XrdCl::Socket::WriteRaw().

## 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

Definition at line 60 of file XrdClStatus.hh.

Referenced by XrdCl::Stream::Initialize(), XrdCl::MessageUtils::RedirectMessage(), and XrdCl::MessageUtils::SendMessage().

## 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

const uint64_t XrdCl::ExDbgMsg = 0x0000000000001000ULL

Definition at line 44 of file XrdClConstants.hh.

Referenced by XrdCl::XRootDMsgHandler::XRootDMsgHandler(), XrdCl::XRootDMsgHandler::~XRootDMsgHandler(), XrdCl::InQueue::AssignTimeout(), XrdCl::XRootDMsgHandler::Examine(), XrdCl::InQueue::GetHandlerForMessage(), XrdCl::XRootDMsgHandler::Process(), and XrdCl::InQueue::RemoveMessageHandler().

## 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

Definition at line 40 of file XrdClConstants.hh.

Referenced by XrdCl::FileSystemData::AssignLastURL(), XrdCl::FileSystemData::AssignLoadBalancer(), and XrdCl::FileSystemData::Send().

## 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

const uint64_t XrdCl::kLogXrdClHttp = std::numeric_limits<std::uint64_t>::max()

static

Definition at line 16 of file XrdClHttpPlugInUtil.hh.

Referenced by XrdCl::HttpFilePlugIn::HttpFilePlugIn(), XrdCl::HttpFileSystemPlugIn::HttpFileSystemPlugIn(), XrdCl::HttpFilePlugIn::Close(), XrdCl::HttpFileSystemPlugIn::DirList(), XrdCl::HttpFileSystemPlugIn::MkDir(), XrdCl::HttpFileSystemPlugIn::Mv(), XrdCl::HttpFilePlugIn::Open(), XrdCl::HttpFilePlugIn::Read(), XrdCl::HttpFileSystemPlugIn::Rm(), XrdCl::HttpFileSystemPlugIn::RmDir(), SetUpLogging(), XrdCl::HttpFilePlugIn::Stat(), XrdCl::HttpFileSystemPlugIn::Stat(), XrdCl::HttpFilePlugIn::Sync(), XrdCl::HttpFilePlugIn::VectorRead(), and XrdCl::HttpFilePlugIn::Write().

## none

struct XrdCl::None XrdCl::none

static

Referenced by XrdCl::Optional< T >::Optional().

## NullRef< Response >::value

template<typename Response>

Response XrdCl::NullRef< Response >::value

Definition at line 128 of file XrdClOperationHandlers.hh.

Referenced by XrdCl::Arg< T >::Arg(), XrdCl::ArgBase< T >::ArgBase(), XrdCl::Fwd< T >::Fwd(), XrdCl::Fwd< T >::Fwd(), XrdCl::FwdStorage< T >::FwdStorage(), XrdCl::FwdStorage< T >::FwdStorage(), XrdCl::ActionMetrics::addDelays(), XrdCl::ActionMetrics::addIos(), XrdCl::MessageUtils::CreateXAttrVec(), DoXAttr(), XrdCl::Env::GetDefaultIntValue(), XrdCl::Env::GetDefaultStringValue(), XrdCl::Env::GetInt(), XrdCl::Utils::GetIntParameter(), XrdCl::File::GetProperty(), XrdCl::FilePlugIn::GetProperty(), XrdCl::FileStateHandler::GetProperty(), XrdCl::FileSystem::GetProperty(), XrdCl::FileSystemPlugIn::GetProperty(), XrdCl::HttpFilePlugIn::GetProperty(), XrdCl::HttpFileSystemPlugIn::GetProperty(), XrdCl::Recorder::GetProperty(), XrdCl::ZipArchive::GetProperty(), xrdcl_proxy::ProxyPrefixFile::GetProperty(), XrdCl::CheckSumHelper::GetRawCheckSum(), XrdCl::Env::GetString(), XrdCl::Utils::GetStringParameter(), XrdCl::LocalFileHandler::GetXAttr(), XrdCl::Env::ImportInt(), XrdCl::Env::ImportString(), XrdCl::ZipArchive::List(), XrdCl::LocalFileHandler::ListXAttr(), XrdCl::Fwd< T >::operator=(), XrdCl::Fwd< T >::operator=(), XrdCl::FwdStorage< T >::operator=(), XrdCl::FwdStorage< T >::operator=(), XrdCl::Utils::ProcessConfig(), XrdCl::Env::PutInt(), XrdCl::Env::PutString(), XrdCl::SetXAttrFsImpl< HasHndl >::RunImpl(), XrdCl::SetXAttrImpl< HasHndl >::RunImpl(), XrdCl::PropertyList::Set(), XrdCl::PropertyList::Set(), XrdCl::File::SetProperty(), XrdCl::FilePlugIn::SetProperty(), XrdCl::FileStateHandler::SetProperty(), XrdCl::FileSystem::SetProperty(), XrdCl::FileSystemPlugIn::SetProperty(), XrdCl::HttpFilePlugIn::SetProperty(), XrdCl::HttpFileSystemPlugIn::SetProperty(), XrdCl::Recorder::SetProperty(), XrdCl::ZipArchive::SetProperty(), xrdcl_proxy::ProxyPrefixFile::SetProperty(), XrdCl::LocalFileHandler::SetXAttr(), SetXAttr(), and SetXAttr().

## PlugInMgrMsg

const uint64_t XrdCl::PlugInMgrMsg = 0x0000000000000800ULL

Definition at line 43 of file XrdClConstants.hh.

Referenced by XrdCl::PlugInManager::ProcessEnvironmentSettings(), XrdCl::PlugInManager::RegisterDefaultFactory(), and XrdCl::PlugInManager::RegisterFactory().

## PollerMsg

const uint64_t XrdCl::PollerMsg = 0x0000000000000008ULL

Definition at line 35 of file XrdClConstants.hh.

Referenced by XrdCl::PollerBuiltIn::AddSocket(), XrdCl::PollerFactory::CreatePoller(), XrdCl::PollerBuiltIn::EnableReadNotification(), XrdCl::PollerBuiltIn::EnableWriteNotification(), XrdCl::PollerBuiltIn::RemoveSocket(), XrdCl::PollerBuiltIn::Start(), and XrdCl::PollerBuiltIn::Stop().

## PostMasterMsg

const uint64_t XrdCl::PostMasterMsg = 0x0000000000000010ULL

Definition at line 36 of file XrdClConstants.hh.

Referenced by XrdCl::Channel::Channel(), XrdCl::Stream::Stream(), XrdCl::Stream::~Stream(), XrdCl::Stream::CanCollapse(), XrdCl::PostMaster::CollapseRedirect(), XrdCl::Socket::Connect(), XrdCl::Stream::DisableIfEmpty(), XrdCl::Stream::EnableLink(), XrdCl::Stream::ForceError(), XrdCl::Stream::OnConnect(), XrdCl::Stream::OnConnectError(), XrdCl::Stream::OnError(), XrdCl::Stream::OnIncoming(), XrdCl::Stream::OnReadTimeout(), XrdCl::Stream::OnReadyToWrite(), and XrdCl::Stream::Send().

## root_ctx_

Davix::Context* XrdCl::root_ctx_ = NULL

Definition at line 21 of file XrdClHttpFileSystemPlugIn.cc.

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

## root_davix_client_

Davix::DavPosix* XrdCl::root_davix_client_ = NULL

Definition at line 22 of file XrdClHttpFileSystemPlugIn.cc.

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

## 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

Definition at line 45 of file XrdClHttpFilePlugIn.cc.

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

## 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(), main(), 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::ZipArchive::ReadFromImpl, 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

const uint16_t XrdCl::stFatal = 0x0003

Fatal error, it's still an error.

Definition at line 33 of file XrdClStatus.hh.

Referenced by XrdCl::Utils::CheckTPC(), XrdCl::Utils::CheckTPCLite(), XrdCl::AsyncSocketHandler::Connect(), XrdCl::Socket::Cork(), XrdCl::AsyncSocketHandler::DisableUplink(), XrdCl::Stream::EnableLink(), XrdCl::AsyncSocketHandler::EnableUplink(), XrdCl::AsyncVectorReader::GetResponse(), XrdCl::XRootDTransport::HandShake(), XrdCl::Status::IsFatal(), XrdCl::AsyncSocketHandler::OnConnectionReturn(), XrdCl::XRootDMsgHandler::Process(), XrdCl::XRootDTransport::Query(), XrdCl::Stream::Send(), XrdCl::Socket::TlsHandShake(), and XrdCl::Socket::Uncork().

## stOK

const uint16_t XrdCl::stOK = 0x0000

Everything went OK.

Definition at line 31 of file XrdClStatus.hh.

Referenced by XrdCl::Status::Status(), XrdCl::Utils::CheckTPCLite(), XrdCl::Socket::ClassifyErrno(), XrdCl::FileStateHandler::Close(), XrdCl::FileSystem::DirList(), XrdCl::XRootDTransport::GetBody(), XrdCl::XCpCtx::GetChunk(), XrdCl::XRootDTransport::GetHeader(), XrdCl::XRootDTransport::GetMore(), XrdCl::Status::IsOK(), XrdCl::Socket::Poll(), XrdCl::XRootDMsgHandler::Process(), XrdCl::Tls::Read(), XrdCl::AsyncRawReaderIntfc::ReadBytesAsync(), XrdCl::MsgHandler::ReadMessageBody(), XrdCl::Socket::ReadRaw(), XrdCl::Tls::Send(), XrdCl::LocalFileHandler::Truncate(), XrdCl::XRootDTransport::UnMarshallRequest(), XrdCl::AsyncMsgWriter::Write(), and XrdCl::Socket::WriteRaw().

## suAlreadyDone

const uint16_t XrdCl::suAlreadyDone = 4

Definition at line 42 of file XrdClStatus.hh.

Referenced by XrdCl::File::Close(), XrdCl::FileStateHandler::Close(), XrdCl::XRootDTransport::UnMarshallRequest(), and XrdCl::AsyncMsgWriter::Write().

## suContinue

const uint16_t XrdCl::suContinue = 1

Definition at line 39 of file XrdClStatus.hh.

Referenced by XrdCl::XCpCtx::GetChunk(), XrdCl::AssignLastURLHandler::HandleResponseWithHosts(), XrdCl::AssignLBHandler::HandleResponseWithHosts(), XrdCl::XRootDMsgHandler::Process(), XrdCl::Status::ToString(), XrdCl::ResponseHandler::Wrap(), and XrdCl::ResponseHandler::Wrap().

## suDone

const uint16_t XrdCl::suDone = 0

Definition at line 38 of file XrdClStatus.hh.

Referenced by XrdCl::XRootDTransport::GetBody(), XrdCl::XCpCtx::GetChunk(), XrdCl::XRootDTransport::GetHeader(), XrdCl::XRootDTransport::GetMore(), XrdCl::AsyncSocketHandler::HandleHandShake(), XrdCl::AsyncSocketHandler::OnReadWhileHandshaking(), XrdCl::AsyncRawReaderIntfc::ReadBytesAsync(), XrdCl::MsgHandler::ReadMessageBody(), and XrdCl::ClassicCopyJob::Run().

## suNotStarted

const uint16_t XrdCl::suNotStarted = 5

Definition at line 43 of file XrdClStatus.hh.

## suPartial

const uint16_t XrdCl::suPartial = 3

Definition at line 41 of file XrdClStatus.hh.

Referenced by XrdCl::Utils::CheckTPCLite(), XrdCl::FileSystem::DirList(), DoLocate(), DoLS(), DoSpaceInfo(), and XrdCl::FileSystemUtils::GetSpaceInfo().

## suRetry

const uint16_t XrdCl::suRetry = 2

Definition at line 40 of file XrdClStatus.hh.

Referenced by XrdCl::Socket::ClassifyErrno(), XrdCl::AsyncSocketHandler::DoTlsHandShake(), XrdCl::XRootDTransport::GetBody(), XrdCl::XCpCtx::GetChunk(), XrdCl::XRootDTransport::GetHeader(), XrdCl::XRootDTransport::GetMore(), XrdCl::AsyncSocketHandler::HandleHandShake(), XrdCl::AsyncSocketHandler::OnConnectionReturn(), XrdCl::AsyncSocketHandler::OnRead(), XrdCl::AsyncSocketHandler::OnTLSHandShake(), XrdCl::AsyncSocketHandler::OnWrite(), XrdCl::AsyncSocketHandler::OnWriteWhileHandshaking(), XrdCl::AsyncHSReader::Read(), XrdCl::AsyncMsgReader::Read(), XrdCl::AsyncPageReader::Read(), XrdCl::AsyncRawReader::Read(), XrdCl::AsyncVectorReader::Read(), XrdCl::Tls::Read(), XrdCl::AsyncRawReaderIntfc::ReadBytesAsync(), XrdCl::Tls::ReadV(), XrdCl::Socket::Send(), XrdCl::Tls::Send(), XrdCl::Status::ToString(), XrdCl::AsyncHSWriter::Write(), XrdCl::AsyncMsgWriter::Write(), and XrdCl::XRootDMsgHandler::WriteMessageBody().

## TaskMgrMsg

const uint64_t XrdCl::TaskMgrMsg = 0x0000000000000040ULL

Definition at line 38 of file XrdClConstants.hh.

Referenced by XrdCl::TaskManager::RegisterTask(), XrdCl::TaskManager::RunTasks(), XrdCl::TaskManager::Start(), XrdCl::TaskManager::Stop(), and XrdCl::TaskManager::UnregisterTask().

## theDefaultInts

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

static

Definition at line 122 of file XrdClConstants.hh.

{
{ to_lower( "SubStreamsPerChannel" ), DefaultSubStreamsPerChannel },
{ to_lower( "ConnectionWindow" ), DefaultConnectionWindow },
{ to_lower( "ConnectionRetry" ), DefaultConnectionRetry },
{ to_lower( "RequestTimeout" ), DefaultRequestTimeout },
{ to_lower( "StreamTimeout" ), DefaultStreamTimeout },
{ to_lower( "TimeoutResolution" ), DefaultTimeoutResolution },
{ to_lower( "StreamErrorWindow" ), DefaultStreamErrorWindow },
{ to_lower( "RunForkHandler" ), DefaultRunForkHandler },
{ to_lower( "RedirectLimit" ), DefaultRedirectLimit },
{ to_lower( "WorkerThreads" ), DefaultWorkerThreads },
{ to_lower( "CPChunkSize" ), DefaultCPChunkSize },
{ to_lower( "CPParallelChunks" ), DefaultCPParallelChunks },
{ to_lower( "DataServerTTL" ), DefaultDataServerTTL },
{ to_lower( "LoadBalancerTTL" ), DefaultLoadBalancerTTL },
{ to_lower( "CPInitTimeout" ), DefaultCPInitTimeout },
{ to_lower( "CPTPCTimeout" ), DefaultCPTPCTimeout },
{ to_lower( "CPTimeout" ), DefaultCPTimeout },
{ to_lower( "TCPKeepAlive" ), DefaultTCPKeepAlive },
{ to_lower( "TCPKeepAliveTime" ), DefaultTCPKeepAliveTime },
{ to_lower( "TCPKeepAliveInterval" ), DefaultTCPKeepAliveInterval },
{ to_lower( "TCPKeepAliveProbes" ), DefaultTCPKeepAliveProbes },
{ to_lower( "MultiProtocol" ), DefaultMultiProtocol },
{ to_lower( "ParallelEvtLoop" ), DefaultParallelEvtLoop },
{ to_lower( "MetalinkProcessing" ), DefaultMetalinkProcessing },
{ to_lower( "LocalMetalinkFile" ), DefaultLocalMetalinkFile },
{ to_lower( "XRateThreshold" ), DefaultXRateThreshold },
{ to_lower( "XCpBlockSize" ), DefaultXCpBlockSize },
{ to_lower( "NoDelay" ), DefaultNoDelay },
{ to_lower( "AioSignal" ), DefaultAioSignal },
{ to_lower( "PreferIPv4" ), DefaultPreferIPv4 },
{ to_lower( "MaxMetalinkWait" ), DefaultMaxMetalinkWait },
{ to_lower( "PreserveLocateTried" ), DefaultPreserveLocateTried },
{ to_lower( "NotAuthorizedRetryLimit" ), DefaultNotAuthorizedRetryLimit },
{ to_lower( "PreserveXAttrs" ), DefaultPreserveXAttrs },
{ to_lower( "NoTlsOK" ), DefaultNoTlsOK },
{ to_lower( "TlsNoData" ), DefaultTlsNoData },
{ to_lower( "TlsMetalink" ), DefaultTlsMetalink },
{ to_lower( "ZipMtlnCksum" ), DefaultZipMtlnCksum },
{ to_lower( "IPNoShuffle" ), DefaultIPNoShuffle },
{ to_lower( "WantTlsOnNoPgrw" ), DefaultWantTlsOnNoPgrw },
{ to_lower( "RetryWrtAtLBLimit" ), DefaultRetryWrtAtLBLimit }
};
XrdCl::DefaultPreserveLocateTried
const int DefaultPreserveLocateTried
Definition XrdClConstants.hh:87
XrdCl::DefaultRunForkHandler
const int DefaultRunForkHandler
Definition XrdClConstants.hh:58
XrdCl::DefaultRedirectLimit
const int DefaultRedirectLimit
Definition XrdClConstants.hh:59
XrdCl::DefaultCPInitTimeout
const int DefaultCPInitTimeout
Definition XrdClConstants.hh:65
XrdCl::DefaultXRateThreshold
const int DefaultXRateThreshold
Definition XrdClConstants.hh:76
XrdCl::DefaultLoadBalancerTTL
const int DefaultLoadBalancerTTL
Definition XrdClConstants.hh:64
XrdCl::DefaultMaxMetalinkWait
const int DefaultMaxMetalinkWait
Definition XrdClConstants.hh:86
XrdCl::DefaultTCPKeepAliveProbes
const int DefaultTCPKeepAliveProbes
Definition XrdClConstants.hh:71
XrdCl::DefaultCPChunkSize
const int DefaultCPChunkSize
Definition XrdClConstants.hh:61
XrdCl::DefaultRetryWrtAtLBLimit
const int DefaultRetryWrtAtLBLimit
Definition XrdClConstants.hh:96
XrdCl::DefaultWantTlsOnNoPgrw
const int DefaultWantTlsOnNoPgrw
Definition XrdClConstants.hh:95
XrdCl::DefaultStreamErrorWindow
const int DefaultStreamErrorWindow
Definition XrdClConstants.hh:57
XrdCl::DefaultMultiProtocol
const int DefaultMultiProtocol
Definition XrdClConstants.hh:72
XrdCl::DefaultConnectionRetry
const int DefaultConnectionRetry
Definition XrdClConstants.hh:53
XrdCl::DefaultIPNoShuffle
const int DefaultIPNoShuffle
Definition XrdClConstants.hh:94
XrdCl::DefaultSubStreamsPerChannel
const int DefaultSubStreamsPerChannel
Definition XrdClConstants.hh:51
XrdCl::DefaultConnectionWindow
const int DefaultConnectionWindow
Definition XrdClConstants.hh:52
XrdCl::DefaultDataServerTTL
const int DefaultDataServerTTL
Definition XrdClConstants.hh:63
XrdCl::DefaultCPParallelChunks
const int DefaultCPParallelChunks
Definition XrdClConstants.hh:62
XrdCl::DefaultTlsMetalink
const int DefaultTlsMetalink
Definition XrdClConstants.hh:92
XrdCl::DefaultTimeoutResolution
const int DefaultTimeoutResolution
Definition XrdClConstants.hh:56
XrdCl::DefaultStreamTimeout
const int DefaultStreamTimeout
Definition XrdClConstants.hh:55
XrdCl::DefaultLocalMetalinkFile
const int DefaultLocalMetalinkFile
Definition XrdClConstants.hh:75
XrdCl::DefaultMetalinkProcessing
const int DefaultMetalinkProcessing
Definition XrdClConstants.hh:74
XrdCl::to_lower
static std::string to_lower(std::string str)
Definition XrdClConstants.hh:116
XrdCl::DefaultTCPKeepAliveInterval
const int DefaultTCPKeepAliveInterval
Definition XrdClConstants.hh:70
XrdCl::DefaultXCpBlockSize
const int DefaultXCpBlockSize
Definition XrdClConstants.hh:77
XrdCl::DefaultCPTimeout
const int DefaultCPTimeout
Definition XrdClConstants.hh:67
XrdCl::DefaultTCPKeepAlive
const int DefaultTCPKeepAlive
Definition XrdClConstants.hh:68
XrdCl::DefaultRequestTimeout
const int DefaultRequestTimeout
Definition XrdClConstants.hh:54
XrdCl::DefaultTCPKeepAliveTime
const int DefaultTCPKeepAliveTime
Definition XrdClConstants.hh:69
XrdCl::DefaultPreserveXAttrs
const int DefaultPreserveXAttrs
Definition XrdClConstants.hh:89
XrdCl::DefaultPreferIPv4
const int DefaultPreferIPv4
Definition XrdClConstants.hh:85
XrdCl::DefaultNotAuthorizedRetryLimit
const int DefaultNotAuthorizedRetryLimit
Definition XrdClConstants.hh:88
XrdCl::DefaultWorkerThreads
const int DefaultWorkerThreads
Definition XrdClConstants.hh:60
XrdCl::DefaultAioSignal
const int DefaultAioSignal
Definition XrdClConstants.hh:84
XrdCl::DefaultCPTPCTimeout
const int DefaultCPTPCTimeout
Definition XrdClConstants.hh:66
XrdCl::DefaultNoDelay
const int DefaultNoDelay
Definition XrdClConstants.hh:82
XrdCl::DefaultTlsNoData
const int DefaultTlsNoData
Definition XrdClConstants.hh:91
XrdCl::DefaultNoTlsOK
const int DefaultNoTlsOK
Definition XrdClConstants.hh:90
XrdCl::DefaultParallelEvtLoop
const int DefaultParallelEvtLoop
Definition XrdClConstants.hh:73
XrdCl::DefaultZipMtlnCksum
const int DefaultZipMtlnCksum
Definition XrdClConstants.hh:93

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 },
{ to_lower( "CpRetryPolicy" ), DefaultCpRetryPolicy }
}
XrdCl::DefaultClConfFile
const char *const DefaultClConfFile
Definition XrdClConstants.hh:112
XrdCl::DefaultCpTarget
const char *const DefaultCpTarget
Definition XrdClConstants.hh:113
XrdCl::DefaultClConfDir
const char *const DefaultClConfDir
Definition XrdClConstants.hh:111
XrdCl::DefaultClientMonitorParam
const char *const DefaultClientMonitorParam
Definition XrdClConstants.hh:103
XrdCl::DefaultOpenRecovery
const char *const DefaultOpenRecovery
Definition XrdClConstants.hh:108
XrdCl::DefaultPlugIn
const char *const DefaultPlugIn
Definition XrdClConstants.hh:105
XrdCl::DefaultPollerPreference
const char *const DefaultPollerPreference
Definition XrdClConstants.hh:100
XrdCl::DefaultNetworkStack
const char *const DefaultNetworkStack
Definition XrdClConstants.hh:101
XrdCl::DefaultPlugInConfDir
const char *const DefaultPlugInConfDir
Definition XrdClConstants.hh:104
XrdCl::DefaultReadRecovery
const char *const DefaultReadRecovery
Definition XrdClConstants.hh:106
XrdCl::DefaultWriteRecovery
const char *const DefaultWriteRecovery
Definition XrdClConstants.hh:107
XrdCl::DefaultGlfnRedirector
const char *const DefaultGlfnRedirector
Definition XrdClConstants.hh:109
XrdCl::DefaultCpRetryPolicy
const char *const DefaultCpRetryPolicy
Definition XrdClConstants.hh:114
XrdCl::DefaultTlsDbgLvl
const char *const DefaultTlsDbgLvl
Definition XrdClConstants.hh:110
XrdCl::DefaultClientMonitor
const char *const DefaultClientMonitor
Definition XrdClConstants.hh:102

Definition at line 167 of file XrdClConstants.hh.

{
{ 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 },
{ to_lower( "CpRetryPolicy" ), DefaultCpRetryPolicy }
};

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

const uint64_t XrdCl::UtilityMsg = 0x0000000000000002ULL

Definition at line 33 of file XrdClConstants.hh.

Referenced by XrdCl::ClassicCopyJob::ClassicCopyJob(), XrdCl::ThirdPartyCopyJob::ThirdPartyCopyJob(), XrdCl::TPFallBackCopyJob::TPFallBackCopyJob(), XrdCl::CopyProcess::AddJob(), XrdCl::CheckSumManager::Calculate(), XrdCl::Utils::CheckTPC(), XrdCl::Utils::CheckTPCLite(), XrdCl::ForkHandler::Child(), child(), XrdCl::URL::FromString(), XrdCl::CheckSumManager::GetCalculator(), XrdCl::CheckSumHelper::GetCheckSum(), XrdCl::Utils::GetHostAddresses(), XrdCl::Env::GetInt(), XrdCl::Utils::GetLocalCheckSum(), XrdCl::DefaultEnv::GetMonitor(), XrdCl::Utils::GetRemoteCheckSum(), XrdCl::Env::GetString(), XrdCl::Env::ImportInt(), XrdCl::Env::ImportString(), XrdCl::CheckSumHelper::Initialize(), XrdCl::XCpCtx::Initialize(), XrdCl::ForkHandler::Parent(), parent(), XrdCl::CopyProcess::Prepare(), XrdCl::ForkHandler::Prepare(), prepare(), XrdCl::Utils::ProcessConfigDir(), XrdCl::Env::PutInt(), XrdCl::Env::PutString(), XrdCl::ClassicCopyJob::Run(), XrdCl::ThirdPartyCopyJob::Run(), and XrdCl::TPFallBackCopyJob::Run().

## XRootDMsg

const uint64_t XrdCl::XRootDMsg = 0x0000000000000080ULL

Definition at line 39 of file XrdClConstants.hh.

Referenced by XrdCl::XRootDMsgHandler::Examine(), XrdCl::XRootDMsgHandler::InspectStatusRsp(), XrdCl::XRootDTransport::MessageReceived(), XrdCl::XRootDMsgHandler::OnStatusReady(), XrdCl::XRootDMsgHandler::OnStreamEvent(), XrdCl::XRootDMsgHandler::Process(), XrdCl::AsyncDiscardReader::Read(), XrdCl::AsyncRawReader::Read(), XrdCl::AsyncVectorReader::Read(), XrdCl::MessageUtils::RedirectMessage(), XrdCl::MessageUtils::SendMessage(), XrdEc::Reader::VectorRead(), and XrdCl::XRootDMsgHandler::WriteMessageBody().

## XRootDTransportMsg

const uint64_t XrdCl::XRootDTransportMsg = 0x0000000000000020ULL

Definition at line 37 of file XrdClConstants.hh.

Referenced by XrdCl::XRootDTransport::Disconnect(), XrdCl::XRootDTransport::GetHeader(), XrdCl::XRootDTransport::GetMore(), XrdCl::XRootDTransport::HandShake(), XrdCl::XRootDTransport::HandShakeDone(), XrdCl::XRootDTransport::IsStreamBroken(), XrdCl::XRootDTransport::IsStreamTTLElapsed(), XrdCl::XRootDTransport::LogErrorResponse(), XrdCl::XRootDTransport::MessageReceived(), XrdCl::XRootDTransport::MultiplexSubStream(), XrdCl::XRootDTransport::NbConnectedStrm(), and XrdCl::XRootDTransport::SubStreamNumber().

## ZipMsg

const uint64_t XrdCl::ZipMsg = 0x0000000000004000ULL

Definition at line 46 of file XrdClConstants.hh.

Referenced by XrdCl::ZipArchive::AppendFile(), XrdCl::ZipArchive::CloseArchive(), XrdCl::ZipArchive::OpenArchive(), XrdCl::ZipArchive::OpenFile(), and XrdCl::ZipArchive::ReadFromImpl.