src/URL/URLcache.pm

#
# URLcache.pm
#
# Originally Written by Christopher Williams
#
# Description
# -----------
# Simple url->file lookup (persistent)
#
# Interface
# ---------
# new(cachedir)         : A new URLcache object in a given directory
# store(url,file)       : store a url/file combination
# file(url)             : return the file for a given url
# delete(url)           : remove from cache url
# clear()               : clear cache
# filestore()           : Return the directory to download files to
# filename(url)         : return a unique file/dir in cache for the given url
# updatenumber(int)     : return an integer number changed with each store

package URL::URLcache;
require 5.004;
use Utilities::HashDB;

sub new {
        my $class=shift;
        $self={};
        bless $self, $class;
        $self->init(@_);
        return $self;
}

sub filestore {
        my $self=shift;
        return $self->{cachedir};
}

sub filename {
        my $self=shift;
        my $url=shift;
        
        my $filenumber;

        my $file=$self->file($url);
        if ( $file eq "" ) { 
          # need to generate a new filename - a random number will do
          srand();
          do {
            $filenumber=int(rand 9999999)+1;
            $file=$self->filestore()."/".$filenumber;
          } until ( ! ( -e $file ) );
        }
        return $file;
}

sub init {
        my $self=shift;
        $self->{cachetop}=shift;
        $self->{cachedir}=$self->{cachetop}."/files";
        AddDir::adddir($self->{cachedir});

        $self->{cacheindex}=$self->{cachetop}."/index.db";
        $self->{cacheseqindex}=$self->{cachetop}."/seqnumb.db";
        $self->{urlDB}=Utilities::HashDB->new();
        $self->{urlDBupdate}=Utilities::HashDB->new();
        if ( -f $self->{cacheindex} ) {
          $self->{urlDB}->restore($self->{cacheindex});
        }
        else {
          AddDir::adddir($self->{cachedir});
        }
        if ( -f $self->{cacheseqindex} ) {
          $self->{urlDBupdate}->restore($self->{cacheseqindex});
        }
}

sub file {
        my $self=shift;
        my $url=shift;

        my @found=$self->{urlDB}->getdata($url);
        return ( ($#found == -1)?"":$found[0]);
}

sub delete {
        my $self=shift;
        my $url=shift;
        unlink ($self->{urlDB}->getdata($URL));
        $self->{urlDB}->deletedata($url);
        $self->{urlDB}->store($self->{cacheindex});
}

sub store {
        my $self=shift;
        my $url=shift;
        my $file=shift;

        $self->{urlDB}->deletedata($url);
        $self->{urlDB}->setdata($file,$url);
        $self->{urlDB}->store($self->{cacheindex});

        # Keep a track of changes
        my ($sequencenumber)=$self->{urlDBupdate}->getdata($url);
        if ( ! defined $sequencenumber ) { $sequencenumber=0 };
        $sequencenumber=$sequencenumber+1;
        $self->{urlDBupdate}->deletedata($url);
        $self->{urlDBupdate}->setdata($sequencenumber,$url);
        $self->{urlDBupdate}->store($self->{cacheseqindex});
}

sub updatenumber {
        my $self=shift;
        my $url=shift;

        return $self->{urlDBupdate}->getdata($url);
}

sub clear {
        my $self=shift;
        foreach $item ( $self->{urlDB}->match() ) {
          $self->delete($item->keys());
        }
}
Revision:	1.3
Committed:	Tue Nov 9 15:57:58 1999 UTC (25 years, 6 months ago) by williamc
Content type:	text/plain
Branch:	MAIN
Changes since 1.2:	+21 -0 lines
Log Message:	Added updatenumber for change tracking
#	User	Rev	Content
1	williamc	1.1	#
2			# URLcache.pm
3			#
4			# Originally Written by Christopher Williams
5			#
6			# Description
7			# -----------
8	williamc	1.2	# Simple url->file lookup (persistent)
9	williamc	1.1	#
10			# Interface
11			# ---------
12	williamc	1.2	# new(cachedir) : A new URLcache object in a given directory
13	williamc	1.1	# store(url,file) : store a url/file combination
14	williamc	1.2	# file(url) : return the file for a given url
15	williamc	1.1	# delete(url) : remove from cache url
16			# clear() : clear cache
17	williamc	1.2	# filestore() : Return the directory to download files to
18			# filename(url) : return a unique file/dir in cache for the given url
19	williamc	1.3	# updatenumber(int) : return an integer number changed with each store
20	williamc	1.1
21			package URL::URLcache;
22			require 5.004;
23			use Utilities::HashDB;
24
25			sub new {
26			my $class=shift;
27			$self={};
28			bless $self, $class;
29			$self->init(@_);
30			return $self;
31			}
32
33	williamc	1.2	sub filestore {
34			my $self=shift;
35			return $self->{cachedir};
36			}
37
38			sub filename {
39			my $self=shift;
40			my $url=shift;
41
42			my $filenumber;
43
44			my $file=$self->file($url);
45			if ( $file eq "" ) {
46			# need to generate a new filename - a random number will do
47			srand();
48			do {
49			$filenumber=int(rand 9999999)+1;
50			$file=$self->filestore()."/".$filenumber;
51			} until ( ! ( -e $file ) );
52			}
53			return $file;
54			}
55
56	williamc	1.1	sub init {
57			my $self=shift;
58	williamc	1.2	$self->{cachetop}=shift;
59			$self->{cachedir}=$self->{cachetop}."/files";
60			AddDir::adddir($self->{cachedir});
61	williamc	1.1
62	williamc	1.2	$self->{cacheindex}=$self->{cachetop}."/index.db";
63	williamc	1.3	$self->{cacheseqindex}=$self->{cachetop}."/seqnumb.db";
64	williamc	1.1	$self->{urlDB}=Utilities::HashDB->new();
65	williamc	1.3	$self->{urlDBupdate}=Utilities::HashDB->new();
66	williamc	1.1	if ( -f $self->{cacheindex} ) {
67			$self->{urlDB}->restore($self->{cacheindex});
68			}
69			else {
70			AddDir::adddir($self->{cachedir});
71			}
72	williamc	1.3	if ( -f $self->{cacheseqindex} ) {
73			$self->{urlDBupdate}->restore($self->{cacheseqindex});
74			}
75	williamc	1.1	}
76
77			sub file {
78			my $self=shift;
79			my $url=shift;
80
81	williamc	1.2	my @found=$self->{urlDB}->getdata($url);
82			return ( ($#found == -1)?"":$found[0]);
83	williamc	1.1	}
84
85			sub delete {
86			my $self=shift;
87			my $url=shift;
88	williamc	1.2	unlink ($self->{urlDB}->getdata($URL));
89	williamc	1.1	$self->{urlDB}->deletedata($url);
90			$self->{urlDB}->store($self->{cacheindex});
91			}
92
93			sub store {
94			my $self=shift;
95			my $url=shift;
96			my $file=shift;
97
98			$self->{urlDB}->deletedata($url);
99			$self->{urlDB}->setdata($file,$url);
100			$self->{urlDB}->store($self->{cacheindex});
101	williamc	1.3
102			# Keep a track of changes
103			my ($sequencenumber)=$self->{urlDBupdate}->getdata($url);
104			if ( ! defined $sequencenumber ) { $sequencenumber=0 };
105			$sequencenumber=$sequencenumber+1;
106			$self->{urlDBupdate}->deletedata($url);
107			$self->{urlDBupdate}->setdata($sequencenumber,$url);
108			$self->{urlDBupdate}->store($self->{cacheseqindex});
109			}
110
111			sub updatenumber {
112			my $self=shift;
113			my $url=shift;
114
115			return $self->{urlDBupdate}->getdata($url);
116	williamc	1.1	}
117
118			sub clear {
119			my $self=shift;
120	williamc	1.2	foreach $item ( $self->{urlDB}->match() ) {
121			$self->delete($item->keys());
122			}
123	williamc	1.1	}