#include <HTTPCacheTable.h>

Classes
struct	CacheEntry

Public Types
typedef vector< CacheEntry * >	CacheEntries

typedef CacheEntries::iterator	CacheEntriesIter

typedef CacheEntries **	CacheTable

Public Member Functions
void	bind_entry_to_data (CacheEntry entry, FILE body)

string	create_hash_directory (int hash)

void	create_location (CacheEntry *entry)

void	delete_by_hits (int hits)

void	delete_by_size (unsigned int size)

void	delete_expired_entries (time_t time=0)

	HTTPCacheTable (const string &cache_root, int block_size)

bool	is_locked_read_responses ()

void	uncouple_entry_from_data (FILE *body)


unsigned long	get_current_size () const

void	set_current_size (unsigned long sz)

unsigned int	get_block_size () const

void	set_block_size (unsigned int sz)

int	get_new_entries () const

void	increment_new_entries ()

string	get_cache_root ()

void	set_cache_root (const string &cr)

Cache Index
These methods manage the cache's index file. Each cache holds an index file named .index which stores the cache's state information.
bool	cache_index_delete ()

bool	cache_index_read ()

CacheEntry *	cache_index_parse_line (const char *line)

void	cache_index_write ()

Friends
class	HTTPCacheTest

Methods to manipulate instances of CacheEntry.
void	delete_all_entries ()

void	add_entry_to_cache_table (CacheEntry *entry)

void	remove_cache_entry (HTTPCacheTable::CacheEntry *entry)

void	remove_entry_from_cache_table (const string &url)

CacheEntry *	get_locked_entry_from_cache_table (const string &url)

CacheEntry *	get_write_locked_entry_from_cache_table (const string &url)

void	calculate_time (HTTPCacheTable::CacheEntry *entry, int default_expiration, time_t request_time)

void	parse_headers (HTTPCacheTable::CacheEntry *entry, unsigned long max_entry_size, const vector< string > &headers)

Detailed Description

The table of entries in the client-side cache. This class maintains a table of CacheEntries, where one instance of CacheEntry is made for each item in the cache. When an item is accessed it is either locked for reading or writing. When locked for reading the entry is recorded on a list of read-locked entries. The caller must explicitly free the entry for it to be removed from this list (which is the only way it can be opened for writing). An entry can be accessed by multiple readers but only one writer.

Note: The CacheEntry class used to contain a lock that was used to ensure that the entry was locked during any changes to any of its fields. That has been removed - its now the responsibility of the caller. This change was made because it's likely the caller will need to lock all of the methods that operate on a CacheEntry anyway, so the CacheEntry-specific lock was redundant.

Definition at line 101 of file HTTPCacheTable.h.

Member Function Documentation

◆ add_entry_to_cache_table()

void libdap::HTTPCacheTable::add_entry_to_cache_table ( CacheEntry * entry )

Add a CacheEntry to the cache table. As each entry is read, load it into the in-memory cache table and update the HTTPCache's current_size. The later is used by the garbage collection method.

Parameters

entry The CacheEntry instance to add.

Definition at line 562 of file HTTPCacheTable.cc.

◆ cache_index_delete()

bool libdap::HTTPCacheTable::cache_index_delete ( )

Remove the cache index file.

A private method.

Returns: True if the file was deleted, otherwise false.

Definition at line 282 of file HTTPCacheTable.cc.

◆ cache_index_parse_line()

HTTPCacheTable::CacheEntry * libdap::HTTPCacheTable::cache_index_parse_line ( const char * line )

Parse one line of the index file.

A private method.

Parameters

line	A single line from the .index file.

Returns: A CacheEntry initialized with the information from line.

Definition at line 331 of file HTTPCacheTable.cc.

◆ cache_index_read()

bool libdap::HTTPCacheTable::cache_index_read ( )

Read the saved set of cached entries from disk. Consistency between the in-memory cache and the index is maintained by only reading the index file when the HTTPCache object is created!

A private method.

Returns: True when a cache index was found and read, false otherwise.

Definition at line 298 of file HTTPCacheTable.cc.

◆ cache_index_write()

void libdap::HTTPCacheTable::cache_index_write ( )

Walk through the list of cached objects and write the cache index file to disk. If the file does not exist, it is created. If the file does exist, it is overwritten. As a side effect, zero the new_entries counter.

A private method.

Exceptions

Error Thrown if the index file cannot be opened for writing.

Note: The HTTPCache destructor calls this method and silently ignores this exception.

Definition at line 402 of file HTTPCacheTable.cc.

◆ calculate_time()

void libdap::HTTPCacheTable::calculate_time	(	HTTPCacheTable::CacheEntry *	entry,
		int	default_expiration,
		time_t	request_time
	)

Calculate the corrected_initial_age of the object. We use the time when this function is called as the response_time as this is when we have received the complete response. This may cause a delay if the response header is very big but should not cause any incorrect behavior.

A private method.

Parameters

entry	The CacheEntry object.
default_expiration	The default value of the cached object's expiration time.
request_time	When was the request made? I think this value must be passed into the method that calls this method...

Definition at line 761 of file HTTPCacheTable.cc.

◆ create_hash_directory()

string libdap::HTTPCacheTable::create_hash_directory ( int hash )

Create the directory path for cache file. The cache uses a set of directories within d_cache_root to store individual responses. The name of the directory that holds a given response is the value returned by the get_hash() function (i.e., it's a number). If the directory exists, this method does nothing.

A private method.

Parameters

hash	The hash value (i.e., directory name). An integer between 0 and CACHE_TABLE_SIZE (See HTTPCache.h).

Returns: The pathname to the directory (even if it already existed).

Exceptions

Error Thrown if the directory cannot be created.

Definition at line 447 of file HTTPCacheTable.cc.

◆ create_location()

void libdap::HTTPCacheTable::create_location ( HTTPCacheTable::CacheEntry * entry )

Create the directory for this url (using the hash value from get_hash()) and a file within that directory to hold the response's information. The cache name and cache_body_fd fields of entry are updated.

mkstemp opens the file it creates, which is a good thing but it makes tracking resources hard for the HTTPCache object (because an exception might cause a file descriptor resource leak). So I close that file descriptor here.

A private method.

Parameters

entry The cache entry object to operate on.

Exceptions

Error If the file for the response's body cannot be created.

Definition at line 505 of file HTTPCacheTable.cc.

◆ get_locked_entry_from_cache_table()

HTTPCacheTable::CacheEntry * libdap::HTTPCacheTable::get_locked_entry_from_cache_table ( const string & url )

Get a pointer to a CacheEntry from the cache table.

Parameters

url	Look for this URL.

Definition at line 588 of file HTTPCacheTable.cc.

◆ get_write_locked_entry_from_cache_table()

HTTPCacheTable::CacheEntry * libdap::HTTPCacheTable::get_write_locked_entry_from_cache_table ( const string & url )

Get a pointer to a CacheEntry from the cache table. Providing a way to pass the hash code into this method makes it easier to test for correct behavior when two entries collide. 10/07/02 jhrg

Parameters

url	Look for this URL.

Returns: The matching CacheEntry instance or NULL if none was found.

Definition at line 627 of file HTTPCacheTable.cc.

◆ parse_headers()

void libdap::HTTPCacheTable::parse_headers	(	HTTPCacheTable::CacheEntry *	entry,
		unsigned long	max_entry_size,
		const vector< string > &	headers
	)

Parse various headers from the vector (which can be retrieved from libcurl once a response is received) and load the CacheEntry object with values. This method should only be called with headers from a response (it should not be used to parse request headers).

A private method.

Parameters

entry	Store values from the headers here.
max_entry_size	DO not cache entries larger than this.
headers	A vector of header lines.

Definition at line 804 of file HTTPCacheTable.cc.

◆ remove_cache_entry()

void libdap::HTTPCacheTable::remove_cache_entry ( HTTPCacheTable::CacheEntry * entry )

Remove a CacheEntry. This means delete the entry's files on disk and free the CacheEntry object. The caller should null the entry's pointer in the cache_table. The total size of the cache is decremented once the entry is deleted.

Parameters

entry The CacheEntry to delete.

Exceptions

InternalErr Thrown if entry is in use.

Definition at line 653 of file HTTPCacheTable.cc.

◆ remove_entry_from_cache_table()

void libdap::HTTPCacheTable::remove_entry_from_cache_table ( const string & url )

Find the CacheEntry for the given url and remove both its information in the persistent store and the entry in d_cache_table. If url is not in the cache, this method does nothing.

Parameters

url	Remove this URL's entry.

Exceptions

InternalErr Thrown if the CacheEntry for url is locked.

Definition at line 701 of file HTTPCacheTable.cc.

The documentation for this class was generated from the following files:

Classes

Public Types

Public Member Functions

Friends

Methods to manipulate instances of CacheEntry.

Detailed Description

Member Function Documentation

◆ add_entry_to_cache_table()

◆ cache_index_delete()

◆ cache_index_parse_line()

◆ cache_index_read()

◆ cache_index_write()

◆ calculate_time()

◆ create_hash_directory()

◆ create_location()

◆ get_locked_entry_from_cache_table()

◆ get_write_locked_entry_from_cache_table()

◆ parse_headers()

◆ remove_cache_entry()

◆ remove_entry_from_cache_table()