ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/COMP/SCRAM/src/URL/URLhandler.pm

Comparing COMP/SCRAM/src/URL/URLhandler.pm (file contents):
Revision 1.5 by williamc, Wed Sep 29 07:29:16 1999 UTC vs.
Revision 1.11 by williamc, Wed Nov 17 19:14:38 1999 UTC

#	Line 1 | Line 1
1	<	# url handler -> returns the location of thefilu&# Interface
1	>	# url handler -> returns the location of the file
2	>	# Interface
3		# ---------
4	<	# new() :
5	<	# new(cachedir)       : A new urlhandler with a defined default cahce directory
6	<	# get(url)            : download from the specified url to the default cache
7	<	# get(url,dirlocation)   : download to the specified directory
4	>	# new(cache)       : A new urlhandler with a defined default cahce directory
5	>	# download(url,[location]) : as get but always download
6	>	# get(url,[location]) : download from the specified url to cache or location
7	>	#                       return the full url path name incl. any base expansion
8	>	#                       and the filename downloaded to
9		# setbase(type,variablehash) : set the url defaults for a specific url type
10	<	#                              arguments are dependenton type
10	>	#                              arguments are dependent on type
11		# unsetbase(type)  : deactivate a previously set base
12	<	# setcache(dir)    : set the default cache location
12	>	# currentbase(type) : return the current base for the given type
13		#
14		# ----------------------------------------------------------------------
13	–	# returns file location - or crashes out
14	–	# can pass a file name for the item to be stored as
15	–	# if not then stores in a default cache.
15
16		package URL::URLhandler;
17		require 5.004;
18		use Utilities::AddDir;
19	<	use URL::URL_base;
19	>	use URL::URLcache;
20	>	use URL::URLclass;
21	>	use URL::URLbase;
22		use Carp;
23
24		sub new {
#	Line 33 | Line 34 | sub init {
34		use Utilities::AddDir;
35		my $self=shift;
36		my $cache=shift;
36	–	if (! defined $cache  ) { $cache="/tmp/SCRAMcache" }; # default cache
37	–	AddDir::adddir($cache);
37		$self->{cache}=$cache;
38	+	$self->{dummybase}=URL::URLbase->new({});
39	+	$self->{cachestore}=$self->{cache}->filestore();
40		use URL::URL_cvs;
41		use URL::URL_cvsfile;
42		use URL::URL_file;
43	+	use URL::URL_filed;
44		$self->{urlmodules}={
45		'cvsfile' => 'URL::URL_cvsfile',
46		'cvs' => 'URL::URL_cvs',
47	<	'file' => 'URL::URL_file'
47	>	'file' => 'URL::URL_file',
48	>	'filed' => 'URL::URL_filed'
49		};
47	–	$self->{filebase}="";
48	–	$self->setbase("file", {}); # Base file as default
50		}
51
52	<	sub setcache {
52	>	sub get {
53		my $self=shift;
54	<	my $cache=shift;
54	>	my $origurl=shift;
55	>	my $file="";
56
57	<	$self->{cache}=$cache;
57	>	my $url=URL::URLclass->new($origurl);
58	>	my $type=$url->type();
59	>	$url->expandurl($self->currentbase($type));
60	>	my $fullurl=$url->url();
61	>
62	>	my $location=$self->{cache}->file($fullurl);
63	>	if ( $location ne "" ) {
64	>	$file=$self->{cache}->file($location);
65	>	#print " Already defined file --".$location." -- ".$file."\n";
66	>	}
67	>	else {
68	>	($fullurl,$file)=$self->download($origurl, @_);
69	>	}
70	>	return ($fullurl, $file);
71		}
72
73	<	sub get ($@) {
73	>	sub download {
74		my $self=shift;
75	<	my $origurl=shift;
76	<	my $dirname=shift;
77	<	my $rest;
78	<	my $type;
79	<	my $url;
80	<	my $version;
81	<	my $rv="";
82	<
83	<	if ( ! defined $dirname ) {
84	<	$dirname=$self->{cache};
85	<	}
86	<	chdir $dirname or carp "Unable to Enter Directory $dirname $!\n";
72	<	chomp $origurl;
73	<	# get our version info from the url (after last ??)
74	<	( $url, $version) = split /\?\?/, $origurl;
75	<	if ( $url=~/:/ ) {
76	<	($type,$rest) = split /:/, $url;
77	<	}
78	<	else {
79	<	$type='label';
80	<	$rest=$url.":".$version;
81	<	}
82	<	if ( ! ( exists $self->{'urlmodules'}{$type}) ) {
83	<	print "URLhandler: Unsupported type $type\n";
84	<	carp;
85	<	}
86	<	else {
87	<	if ( $#{$self->{urlostack}{$type}} < 0 ) {
88	<	print "URLhandler : base not set for type $type \n";
89	<	}
90	<	else {
91	<	$rv=
92	<	eval{${$self->{urlostack}{$type}}[$#{$self->{urlostack}{$type}}]}->
93	<	get($rest);
94	<	}
75	>	my $origurl=shift;
76	>
77	>	print "downloading $origurl\n";
78	>	# Process the URL string
79	>	my $url=URL::URLclass->new($origurl);
80	>	my $type=$url->type();
81	>	$urltypehandler=$self->_typehandler($type);
82	>	$url->expandurl($self->currentbase($type));
83	>
84	>	# Generate a location name if not provided
85	>	if ( @_ ) {
86	>	$location=shift;
87		}
88	<	if ( $rv ne "" ) {
89	<	$rv=$dirname."/".$rv;
88	>	else {
89	>	$location=$self->{cache}->filename($url->url());
90		}
91	<	return $rv;
91	>	# -- get the file from the appropriate handler
92	>	if ( defined $urltypehandler ) {
93	>	# Call the download module
94	>	$file=eval{$urltypehandler->get($url, $location)};
95	>	}
96	>
97	>	# now register it in the cache if successful
98	>	if ( $file ) {
99	>	$self->{cache}->store($url->url(), $location);
100	>	$self->{cache}->store($location, $file);
101	>	}
102	>	return ($url->url(), $file);
103		}
104
105		sub setbase {
#	Line 105 | Line 108 | sub setbase {
108		my @args=@_;
109		my $oref;
110
111	<	# Check type is supported
112	<	if ( ! exists $self->{urlmodules}{$type} ) {
113	<	print "URLhandler error: Unsupported type $type\n";
114	<	return 1;
112	<	}
113	<	else {
114	<	# A new URL object - pushed onto the stack
115	<	$oref=eval{$self->{urlmodules}{$type}}->new();
116	<	push @{$self->{urlostack}{$type}}, $oref;
117	<	$oref->setbase(@args);
118	<	}
111	>	$self->checktype($type);
112	>	# make a new base object
113	>	my $base=URL::URLbase->new(@_);
114	>	push @{$self->{"basestack"}{$type}}, $base;
115		}
116
117		sub unsetbase {
#	Line 123 | Line 119 | sub unsetbase {
119		my $type=shift;
120		my $oref;
121
122	<	# Check type is supported
122	>	$self->checktype($type);
123	>	# pop off the stack and call the unset base method
124	>	if ( $#{$self->{basestack}{$type}} >=0 ) {
125	>	my $base=pop @{$self->{basestack}{$type}};
126	>	undef $base;
127	>	}
128	>	else {
129	>	die "URLhandler error: Unable to unset type $type\n";
130	>	}
131	>	# remove the stack if its empty
132	>	if ( $#{$self->{basestack}{$type}} == -1 ) {
133	>	delete $self->{basestack}{$type};
134	>	}
135	>	}
136	>
137	>	sub currentbase {
138	>	my $self=shift;
139	>	my $type=shift;
140	>	my $rv;
141	>
142	>	if ( exists $self->{basestack}{$type} ) {
143	>	$rv=${$self->{basestack}{$type}}[$#{$self->{basestack}{$type}}];
144	>	}
145	>	else {
146	>	$rv=$self->{dummybase};
147	>	}
148	>	return $rv;
149	>	}
150	>
151	>	sub checktype($type) {
152	>	my $self=shift;
153	>	my $type=shift;
154	>
155	>	# Check type is supported
156		if ( ! exists $self->{urlmodules}{$type} ) {
157	<	print "URLhandler error: Unsupported type $type\n";
129	<	return 1;
130	<	}
131	<	else {
132	<	# pop off the stack and call the unset base method
133	<	if ( $#{$self->{urlostack}{$type}} >=0 ) {
134	<	$oref=pop @{$self->{urlostack}{$type}};
135	<	$oref->unsetbase();
136	<	undef $oref;
137	<	}
138	<	else {
139	<	print "URLhandler error: Unable to unset type $type\n";
140	<	return 1;
141	<	}
157	>	die "URLhandler error: Unsupported type $type\n";
158		}
159		}
160
161	<	# ------------------------ General Support Routines ----------------------------
161	>	sub _typehandler {
162	>	my $self=shift;
163	>	my $type=shift;
164	>
165	>	$self->checktype($type);
166
167	<	sub cachefilename {
168	<	my $self=shift;
169	<	use File::Basename;
170	<	use Utilities::AddDir;
171	<	my $filebase=dirname($rest);
172	<	$cache="/tmp/williamc/urlhandler$$";
173	<	adddir($cache);
154	<	$filename=$cache."/".$filebase;
167	>	# instantiate only if it dosnt already exist;
168	>	if ( exists $self->{'urlobjs'}{$type} ) {
169	>	$self->{'urlobjs'}{$type};
170	>	}
171	>	else {
172	>	$self->{'urlobjs'}{$type}=$self->{urlmodules}{$type}->new();
173	>	}
174		}
156	–

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines