A container that maps from a FQDN to a
CacheHostRecord. This is constructed from the contents of
void Match(char const *fqdn, int len, CacheHostResult *result)¶
Search the table for a match for the hostname fqdn, a string of length len. If found the result is placed in result.
- void Match(char const *fqdn, int len, CacheHostResult *result)¶
A wrapper for
CacheHostTable::Match(). This contains the set of cache volumes for the cache host record and is used to perform stripe assignment.
A cache hosting record from
The stripes that are part of the cache volumes. This is the union over the stripes of
unsigned short *vol_hash_table¶
The stripe assignment table. This is an array of indices in to
- Vol **vols¶
An open directory entry. It contains all the information of a
Dirplus additional information from the first
A virtual connection class which accepts input for writing to cache.
Data transfer driver. This contains a set of producers. Each producer is connected to one or more consumers. The tunnel handles events and buffers so that data moves from producers to consumers. The data, as much as possible, is kept in reference counted buffers so that copies are done only when the data is modified or for sources (which acquire data from outside Traffic Server) and sinks (which move data to outside Traffic Server).
Holds the data from a line in
Defined in iocore/cache/P_CacheHttp.h. This is an array of
HTTPInfoobjects and serves as the repository of information about alternates of an object. It is marshaled as part of the metadata for an object in the cache.
Defined in proxy/hdrs/HTTP.h.
This class is a wrapper for
HTTPCacheAlt. It provides the external API for accessing data in the wrapped class. It contains only a pointer (possibly
NULL) to an instance of the wrapped class.
Defined in proxy/hdrs/HTTP.h.
This is the metadata for a single alternate for a cached object. It contains, among other data, the following:
The key for the earliest
Docof the alternate.
The request and response headers.
The fragment offset table.[#fragment-offset-table]_
Timestamps for request and response from origin server.
This represents a storage unit inside a cache volume.
int aggWrite(int event, void *e)¶
Schedule the aggregation buffer to be written to disk.
The number of segments in the volume. This will be roughly the total number of entries divided by the number of entries in a segment. It will be rounded up to cover all entries.
The number of buckets in the volume. This will be roughly the number of entries in a segment divided by
DIR_DEPTH. For currently defined values this is around 16,384 (2^16 / 4). Buckets are used as the targets of the index hash.
EvacuationBlockbuckets. This is sized so there is one bucket for every evacuation span.
int evac_range(off_t low, off_t high, int evac_phase)¶
Start an evacuation if there is any
EvacuationBlockin the range from low to high. Return
0if no evacuation was started, non-zero otherwise.
- int aggWrite(int event, void *e)¶
Defined in iocore/cache/P_CacheVol.h.
The length of this segment including the header length, fragment table, and this structure.
Total length of the entire document not including meta data but including headers.
First index key in the document (the index key used to locate this object in the volume index).
The index key for this fragment. Fragment keys are computationally chained so that the key for the next and previous fragments can be computed from this key.
Fragment type. Currently only
CACHE_FRAG_TYPE_HTTPis used. Other types may be used for cache extensions if those are ever implemented.
Fragment table length, if any. Only the first
Docin an object should contain a fragment table.
The fragment table is a list of offsets relative to the HTTP content (not counting metadata or HTTP headers). Each offset is the byte offset of the first byte in the fragment. The first element in the table is the second fragment (what would be index 1 for an array). The offset for the first fragment is of course always zero and so not stored. The purpose of this is to enable a fast seek for range requests. Given the first
Docthe fragment containing the first byte in the range can be computed and loaded directly without further disk access.
Removed as of version 3.3.0. 
- uint32_t len¶
Header for a span. This is a serialized data structure.
unsigned int magic¶
Holds a magic value :code:
DISK_HEADER_MAGICto indicate the span is valid and initialized.
unsigned int num_volumes¶
Number of cache volumes containing stripes in this span.
unsigned int num_free¶
The number of span blocks defined but not in use.
unsigned int num_used¶
The number of span blocks in use by stripes.
unsigned int num_diskvol_blks¶
The number of span blocks.
A flexible array. The actual length of this array is
num_diskvol_blksand each element describes a span block.
- unsigned int magic¶
A description of a span stripe (Vol) block . This is a serialized data structure.
The cache volume index for this span block.
unsigned int __attribute__((bitfield_3)) type¶
Type of the span block.
unsigned int __attribute__((bitfield_1)) free¶
In use or free flag - set if the span block is not in use by a cache volume.
- int number¶
Container for a magic value,
VOL_MAGIC, to indicate the instance is valid.
Version of the instance.
Epoch time when the stripe was created.
Position of the write cursor, as a byte offset in the stripe.
Location of the write cursor of the most recently completed disk write.
The byte offset in the stripe where the current aggregation buffer will be written.
Generation of this instance.
An array of directory entry indices. Each element is the directory entry of the start of the free list for a segment, in the same order as the segments in the directory.
Indicates if this is a new stripe rather than an existing one. In case a stripe is new ATS decides to clear that stripe(
- int new_block¶
Describes the Disk that contains the stripe identified by vol_number. This class also contains the queue containing all the DiskVolBlock
Number of blocks in the stripe identified by vol_number
- int num_volblocks¶
A cache volume as described in
volume.config. This class represents a single volume.
CacheVolcomprises of stripes spread across Spans(disks)
identification number of this volume
An enumeration of value
Volrepresents a single stripe in the disk. vols contains all the stripes this volume is made up of
per volume stat
- int volume_number¶
This class represents an individual volume.
Identification number of the volume
Used as an indicator if the volume is part of the overall volumes created by ATS
- int number¶
Total number of volumes specified in volume.config
Total number of volumes specified in volume.config for HTTP scheme
- int num_volumes¶
Base object for a cache.
A generic class:CacheHostRecord that contains all cache volumes that are not explicitly assigned in
Vol *key_to_vol(const char *key, const char *host, int host_len)¶
Compute the stripe (
Vol*) for a cache key and host. The host is used to find the appropriate
CacheHostRecordinstance. From there the stripe assignment slot is determined by taking bits 64..83 (20 bits) of the cache key modulo the stripe assignment array count (
VOL_HASH_TABLE_SIZE). These bits are the third 32 bit slice of the key less the bottom
- CacheHostRecord hosttable¶