ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/COMP/SCRAM/src/BuildSystem/Requirements.pm
(Generate patch)

Comparing COMP/SCRAM/src/BuildSystem/Requirements.pm (file contents):
Revision 1.6 by sashby, Thu Nov 15 21:18:15 2001 UTC vs.
Revision 1.23 by sashby, Tue Feb 27 11:59:44 2007 UTC

# Line 15 | Line 15
15   # distributionurl(tool,version) : return the dist info url for the tool
16  
17   package BuildSystem::Requirements;
18 +
19 + BEGIN
20 +   {
21 +   die "\n\n".__PACKAGE__.": this package has been moved to Configuration::Requirements. This one is obsolete and can be removed.\n\n";
22 +   }
23 +
24   use ActiveDoc::ActiveDoc;
25   use Utilities::Verbose;
26  
27   require 5.004;
28   @ISA=qw(Utilities::Verbose);
29 + $BuildSystem::Requirements::self;
30 +
31 + sub new
32 +   {
33 +   my $class=shift;
34 +   # Initialise the global package variable:
35 +   no strict 'refs';
36 +   $self = defined $self ? $self
37 +      : (bless {}, $class );
38 +   $self->{dbstore}=shift;
39 +   $self->{file}=shift;
40 +   $self->{cache}=$self->{dbstore}->cache();
41 +
42 +   if ( @_ )
43 +      {
44 +      $self->arch(shift);
45 +      }
46 +   $self->verbose("Initialising a new Requirements Doc");
47 +   $self->{mydoctype} = "BuildSystem::Requirements";
48 +   $self->{mydocversion}="2.0";
49 +   # Counter for downloaded tools: zero it here. It will
50 +   # be auto-incremented as each tool is selected:
51 +   $self->{selectcounter}=0;
52 +  
53 +   $self->{Arch}=1;
54 +   push @{$self->{ARCHBLOCK}}, $self->{Arch};
55 +   $self->init($self->{file});
56 +   return $self;
57 +   }
58 +
59 + sub toolmanager
60 +   {
61 +   my $self=shift;
62 +  
63 +   @_ ? $self->{toolmanagerobject} = shift
64 +      : $self->{toolmanagerobject};
65 +  
66 +   }
67 +
68 + sub configversion
69 +   {
70 +   my $self=shift;
71 +   @_ ? $self->{configversion} = shift
72 +      : $self->{configversion};
73 +   }
74 +
75 + sub url
76 +   {
77 +   my $self=shift;
78 +  
79 +   if ( @_ )
80 +      {
81 +      $self->{file}=shift;
82 +      }
83 +   return $self->{file};
84 +   }
85 +
86 + sub tools
87 +   {
88 +   my $self=shift;
89 +   return @{$self->{tools}};
90 +   }
91 +
92 + sub toolcomment
93 +   {
94 +   my $self=shift;
95 +   my $tool=shift;
96 +   my $version=shift;
97 +  
98 +   return $self->{reqtext}{$tool}{$version};
99 +   }
100 +
101 + sub distributionurl
102 +   {
103 +   my $self=shift;
104 +   my $tool=shift;
105 +   my $version=shift;
106 +  
107 +   return ( defined $self->{dist}{$tool}{$version})?
108 +      $self->{dist}{$tool}{$version}:undef;
109 +   }
110 +
111 + sub version
112 +   {
113 +   my $self=shift;
114 +   my $tool=shift;
115 +   return $self->{'version'}{$tool};
116 +   }
117 +
118 + sub toolurl
119 +   {
120 +   my $self=shift;
121 +   my $tool=shift;
122 +   return $self->{'url'}{$tool};
123 +   }
124 +
125 + sub init
126 +   {
127 +   my $self=shift;
128 +   my $url=shift;
129 +   my $scramdoc=ActiveDoc::ActiveDoc->new($self->{dbstore});
130 +   $scramdoc->verbosity($self->verbosity());
131 +   $scramdoc->url($url);  
132 +   $scramdoc->newparse("ordering",$self->{mydoctype},'Subs');
133 +   $self->{reqcontext}=0;
134 +   $self->{scramdoc}=$scramdoc;
135 +   undef $self->{restrictstack};
136 +   @{$self->{tools}}=();
137 +   @{$self->{ArchStack}}=();
138 +   $self->verbose("Initial Document Parse");
139 +   $self->{scramdoc}->parse("ordering");
140 +   # Set the config version. If there isn't a version, it means that we
141 +   # have a stand-alone repository for the toolbox, rather than a CVS
142 +   # one. Hence, no CVS tag (== version):
143 +   ($scramdoc->{configurl}->param('version') eq '') ?
144 +      $self->configversion("STANDALONE") :
145 +      $self->configversion($scramdoc->{configurl}->param('version'));
146 +   }
147 +
148 + sub arch
149 +   {
150 +   my $self=shift;
151 +   # $self->arch is the SCRAM_ARCH value:
152 +   if ( @_ )
153 +      {
154 +      $self->{arch}=shift;
155 +      }
156 +   else
157 +      {
158 +      if ( ! defined $self->{arch} )
159 +         {
160 +         $self->{arch}="";
161 +         }
162 +      }
163 +   return $self->{arch};
164 +   }
165 +
166 + sub archlist
167 +   {
168 +   my $self=shift;
169 +   return @{$self->{ArchStack}};
170 +   }
171 +
172 + sub getreqforarch
173 +   {
174 +   my $self=shift;
175 +   my $arch=shift;
176 +  
177 +   if ( ! defined $self->{reqsforarch}{$arch} )
178 +      {
179 +      $self->{reqsforarch}{$arch}=
180 +         BuildSystem::Requirements->new($self->{dbstore},$self->{file},
181 +                                        $arch);
182 +      }
183 +   return $self->{reqsforarch}{$arch};
184 +   }
185 +
186 + sub download
187 +   {
188 +   my $self=shift;
189 +   my $tool;
190 +   $| = 1; # Unbuffer the output
191 +
192 +   print  "Downloading tool descriptions....","\n";
193 +   print  " ";
194 +   foreach $tool ( $self->tools() )
195 +      {
196 +      print "#";
197 +      $self->verbose("Downloading ".$self->toolurl($tool));
198 +      # get into the cache:
199 +      $self->{scramdoc}->urlget($self->toolurl($tool));
200 +      }
201 +   print "\nDone.","\n";
202 +   # So now add the list of downloaded tools, and which were
203 +   # selected, to tool cache:
204 +   print "Tool info cached locally.","\n","\n";
205 +
206 +   # Now copy required info from this object to ToolManager (ToolCache):
207 +   $self->toolmanager()->downloadedtools($self->{tools});
208 +   $self->toolmanager()->defaultversions($self->{version});
209 +   $self->toolmanager()->toolurls($self->{url});
210 +   $self->toolmanager()->selected($self->{selected});
211 +   }
212 +
213 + #sub _autoselect
214 + #   {
215 + #   my $self=shift;
216 + #   if ( @_ )
217 + #      {
218 + #      $self->{autoselect}=shift;
219 + #      }
220 + #   # -- default is true
221 + #   return ((defined $self->{autoselect})?$self->{autoselect}:1);
222 + #   }
223 +
224 + sub require()
225 +   {
226 +   my $self=shift;
227 +   my $name=shift;
228 +   my $hashref=shift;
229 +  
230 +   $self->{scramdoc}->checktag( $name, $hashref, 'version');
231 +   $self->{scramdoc}->checktag( $name, $hashref, 'name');
232 +   $self->{scramdoc}->checktag( $name, $hashref, 'url');
233 +  
234 +   if ( $self->{reqcontext} == 1 )
235 +      {
236 +      $self->{scramdoc}->parseerror(
237 +                                  "Open new $name context without previous </$name>");
238 +      }
239 +   $self->{reqcontext}=1;
240 +   $$hashref{'name'}=~tr[A-Z][a-z];
241 +  
242 +   # Add protection so that architecture tags are obeyed during download:
243 +   if ( $self->{Arch} )
244 +      {
245 +      # Add tool to the tool array:
246 +      push @{$self->{tools}}, $$hashref{'name'};
247 +      
248 +      # If the tool already has an entry, modify the version string to
249 +      # include both versions. The versions can later be separated and
250 +      # parsed as normal:
251 +      if (defined $self->{version}{$$hashref{'name'}})
252 +         {
253 +         # Don't need an extra entry for this tool onto tool array:
254 +         pop @{$self->{tools}}, $$hashref{'name'};
255 +         # Modify the version string to append the other tool version.
256 +         # Separate using a colon:
257 +         my $newversion=$self->{version}{$$hashref{'name'}}.":".$$hashref{'version'};
258 +         $self->{version}{$$hashref{'name'}}=$newversion;
259 +         }
260 +      else
261 +         {
262 +         $self->{version}{$$hashref{'name'}}=$$hashref{'version'};
263 +         }
264 +      # -- make sure the full url is taken
265 +      my $urlobj=$self->{scramdoc}->expandurl($$hashref{'url'});
266 +      $self->{url}{$$hashref{'name'}}=$urlobj->url();
267 +
268 +      $self->{creqtool}=$$hashref{'name'};
269 +      $self->{creqversion}=$$hashref{'version'};
270 +      $self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}="";
271 +      }
272 +   }
273 +
274 + sub require_text
275 +   {
276 +   my $self=shift;
277 +   my $name=shift;
278 +   my $string=shift;
279 +  
280 +   chomp $string;
281 +   $self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}=
282 +      $self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}.
283 +      $string;  
284 +   }
285 +
286 + sub require_end
287 +   {
288 +   my $self=shift;
289 +   my $name=shift;
290 +  
291 +   if ( $self->{reqcontext} != 1 )
292 +      {
293 +      $self->{scramdoc}->parseerror("No matching tag for </$name>");
294 +      }
295 +   else
296 +      {
297 +      $self->{reqcontext}=0;
298 +      }
299 +   }
300 +
301 + sub select_start
302 +   {
303 +   my $self=shift;
304 +   my $name=shift;
305 +   my $hashref=shift;
306 +
307 +   $self->{scramdoc}->checktag( $name, $hashref, 'name');
308 +   $$hashref{'name'}=~tr[A-Z][a-z];
309 +   if ( $self->{Arch} )
310 +      {
311 +      $self->verbose("Selecting ".$$hashref{'name'});
312 +      # Increment counter:
313 +      $self->{selectcounter}++;
314 +      $self->{selected}{$$hashref{'name'}}=$self->{selectcounter};
315 +      }
316 +   }
317 +
318 + sub Arch_Start
319 +   {
320 +   my $self=shift;
321 +   my $name=shift;
322 +   my $hashref=shift;
323 +  
324 +   # Check the architecture tag:
325 +   $self->{scramdoc}->checktag($name, $hashref,'name');  
326 +   ( ($self->arch()=~/$$hashref{name}.*/) )? ($self->{Arch}=1)
327 +      : ($self->{Arch}=0);
328 +  
329 +   $self->verbose(($self->{Arch}?"OK":"skipping")." ".$$hashref{name});
330 +   push @{$self->{ARCHBLOCK}}, $self->{Arch};
331 +   push @{$self->{ArchStack}}, $$hashref{'name'};
332 +   }
333 +
334 + sub Arch_End
335 +   {
336 +   my $self=shift;
337 +   my $name=shift;
338 +   pop @{$self->{ARCHBLOCK}};
339 +   $self->{Arch}=$self->{ARCHBLOCK}[$#{$self->{ARCHBLOCK}}];
340 +   }
341 +
342 + sub disttag
343 +   {
344 +   my $self=shift;
345 +   my $name=shift;
346 +   my $hashref=shift;
347 +  
348 +   if ( exists $$hashref{'url'} )
349 +      {
350 +      $self->{dist}{$self->{creqtool}}{$self->{creqversion}}=
351 +         $$hashref{'url'};
352 +      }
353 +   }
354 +
355 + sub select()
356 +   {
357 +   my ($xmlparser,$name,%attributes)=@_;
358 + #   print "Selecting ".$attributes{'name'},"\n";
359 +   }
360 +
361 + sub select_()
362 +   {}
363 +
364 + sub AUTOLOAD()
365 +   {
366 +   my ($xmlparser,$name,%attributes)=@_;
367 +   return if $AUTOLOAD =~ /::DESTROY$/;
368 +   my $name=$AUTOLOAD;
369 +   $name =~ s/.*://;
370 +   # Delegate missing function calls to the doc parser class:
371 +   $self->{scramdoc}->$name(%attributes);
372 +   }
373  
374 < sub new {
25 <        my $class=shift;
26 <        my $self={};
27 <        bless $self, $class;
28 <        $self->{dbstore}=shift;
29 <        $self->{file}=shift;
30 <        $self->{cache}=$self->{dbstore}->cache();
31 <        if ( @_ ) {
32 <          $self->arch(shift);
33 <        }
34 <        $self->verbose("Initialising a new Requirements Doc");
35 <        $self->{mydocversion}="2.0";
36 <        $self->{Arch}=1;
37 <        push @{$self->{ARCHBLOCK}}, $self->{Arch};
38 <        $self->init($self->{file});
39 <        return $self;
40 < }
41 <
42 < sub url {
43 <        my $self=shift;
44 <        if ( @_ ) {
45 <          $self->{file}=shift;
46 <        }
47 <        return $self->{file}
48 < }
49 <
50 < sub setup {
51 <        my $self=shift;
52 <        my $toolbox=shift;
53 <        print ">> In Requirements: setup()\n";
54 <        my $tool;
55 <        print ">> Looping over tools: ";
56 <        foreach $tool ( $self->selectedtools() )
57 <           {
58 <           print "\t\t Tool: ",$tool,"\n";
59 <           $self->verbose("Setting Up Tool $tool");
60 <           print "\t\t\tGoing to run toolsetup...using $toolbox","\n";
61 <           $toolbox->toolsetup($tool, $self->version($tool), $self->toolurl($tool));
62 <           }
63 < }
64 <
65 < sub tools {
66 <        my $self=shift;
67 <        return @{$self->{tools}};
68 < }
69 <
70 < sub selectedtools {
71 <        my $self=shift;
72 <        my @toollist=();
73 <        foreach $tool (  @{$self->{tools}} ) {
74 <          if ( $self->{selected}{$tool} == 1 ) {
75 <                push @toollist, $tool;
76 <          }
77 <        }
78 <        return @toollist;
79 < }
80 <
81 < sub toolcomment {
82 <        my $self=shift;
83 <        my $tool=shift;
84 <        my $version=shift;
85 <
86 <        return $self->{reqtext}{$tool}{$version};
87 < }
88 <
89 < sub distributionurl {
90 <        my $self=shift;
91 <        my $tool=shift;
92 <        my $version=shift;
93 <
94 <        return ( defined $self->{dist}{$tool}{$version})?
95 <                        $self->{dist}{$tool}{$version}:undef;
96 < }
97 <
98 < sub version {
99 <        my $self=shift;
100 <        my $tool=shift;
101 <        return $self->{'version'}{$tool};
102 < }
103 <
104 < sub toolurl {
105 <        my $self=shift;
106 <        my $tool=shift;
107 <        return $self->{'url'}{$tool};
108 < }
109 <
110 < sub init {
111 <        my $self=shift;
112 <        my $url=shift;
113 <
114 <        my $switch=ActiveDoc::ActiveDoc->new($self->{dbstore});
115 <        $switch->verbosity($self->verbosity());
116 <        $switch->url($url);
117 <        $switch->newparse("ordering");
118 <        $switch->addbasetags("ordering");
119 <        $switch->addtag("ordering","Architecture",
120 <                                        \&Arch_Start,$self,
121 <                                        "", $self,
122 <                                        \&Arch_End, $self);
123 <        $switch->addtag("ordering","Restrict",
124 <                                        \&Restrict_start,$self,
125 <                                        "", $self,
126 <                                        \&Restrict_end, $self);
127 <        $switch->addtag("ordering","deselect",
128 <                                        \&deselect_start,$self,
129 <                                        "", $self,
130 <                                        "", $self);
131 <        $switch->addtag("ordering","select",
132 <                                        \&select_start,$self,
133 <                                        "", $self,
134 <                                        "", $self);
135 <        $switch->addtag("ordering","distribution",
136 <                                        \&disttag,$self);
137 <        $switch->grouptag("Architecture","ordering");
138 <        $switch->addtag("ordering","require",
139 <                                        \&require_start,$self,
140 <                                        \&require_text, $self,
141 <                                        \&require_end, $self);
142 <
143 <        $self->{reqcontext}=0;
144 <        $self->{switch}=$switch;
145 <        undef $self->{restrictstack};
146 <        @{$self->{tools}}=();
147 <        
148 <        my($doctype,$docversion)=$switch->doctype();
149 <        # -- for backwards compatability only parse if we have a docversion
150 <        #    defined
151 <        if ( defined $docversion ) {
152 <          if ( $docversion eq $self->{mydocversion} ) {
153 <            @{$self->{ArchStack}}=();
154 <            $self->verbose("Initial Document Parse");
155 <            $self->{switch}->parse("ordering");
156 <          }
157 <          else {
158 <            $self->verbose("wrong doc version - not parsing");
159 <          }
160 <        }
161 <        else {
162 <          $self->verbose("wrong doc type - not parsing");
163 <        }
164 < }
165 <
166 < sub arch {
167 <        my $self=shift;
168 <        if ( @_ ) {
169 <          $self->{arch}=shift
170 <        }
171 <        else {
172 <          if ( ! defined $self->{arch} ) {
173 <            $self->{arch}="";
174 <          }
175 <        }
176 <        return $self->{arch};
177 < }
178 <
179 < sub archlist {
180 <        my $self=shift;
181 <        return @{$self->{ArchStack}};
182 < }
183 <
184 < sub getreqforarch {
185 <        my $self=shift;
186 <        my $arch=shift;
187 <
188 <        if ( ! defined $self->{reqsforarch}{$arch} ) {
189 <          $self->{reqsforarch}{$arch}=
190 <                BuildSystem::Requirements->new($self->{dbstore},$self->{file},
191 <                                                $arch);
192 <        }
193 <        return $self->{reqsforarch}{$arch};
194 < }
195 <
196 <
197 < sub download {
198 <        my $self=shift;
199 <
200 <        my $tool;
201 <        foreach $tool ( $self->tools() ) {
202 <          $self->verbose("Downloading ".$self->toolurl($tool));
203 <          # get into the cache
204 <          $self->{switch}->urlget($self->toolurl($tool));
205 <        }
206 < }
207 <
208 < sub _autoselect {
209 <        my $self=shift;
210 <        if ( @_ ) {
211 <          $self->{autoselect}=shift;
212 <        }
213 <        # -- default is true
214 <        return ((defined $self->{autoselect})?$self->{autoselect}:1);
215 < }
216 <
217 < # ---- Tag routines
218 <
219 < sub Restrict_start {
220 <        my $self=shift;
221 <        my $name=shift;
222 <        my $hashref=shift;
223 <
224 <        $self->{switch}->checktag( $name, $hashref, 'autoselect');
225 <        if ( $self->{Arch} ) {
226 <        # -- create selection state stack
227 <        push @{$self->{restrictstack}}, $self->_autoselect();
228 <        $self->_autoselect(
229 <                (($$hashref{'autoselect'}=~/true/i)?1:0));
230 <        }
231 < }
232 <
233 < sub Restrict_end {
234 <        my $self=shift;
235 <        my $name=shift;
236 <
237 <        if ( $self->{Arch} ) {
238 <        if ( $#{$self->{restrictstack}} >= 0 ) {
239 <          $self->_autoselect(pop @{$self->{restrictstack}});
240 <        }
241 <        else {
242 <          $self->{switch}->parseerror("Unmatched </$name>");
243 <        }
244 <        }
245 < }
246 <
247 < sub require_start {
248 <        my $self=shift;
249 <        my $name=shift;
250 <        my $hashref=shift;
251 <        
252 <        $self->{switch}->checktag( $name, $hashref, 'version');
253 <        $self->{switch}->checktag( $name, $hashref, 'name');
254 <        $self->{switch}->checktag( $name, $hashref, 'url');
255 <
256 <        if ( $self->{reqcontext} == 1 ) {
257 <          $self->{switch}->parseerror(
258 <                "Open new $name conext without previous </$name>");
259 <        }
260 <        $self->{reqcontext}=1;
261 <        $$hashref{'name'}=~tr[A-Z][a-z];
262 <        push @{$self->{tools}}, $$hashref{'name'};
263 <        $self->{version}{$$hashref{'name'}}=$$hashref{'version'};
264 <        # -- make sure the full url is taken
265 <        my $urlobj=$self->{switch}->expandurl($$hashref{'url'});
266 <        $self->{url}{$$hashref{'name'}}=$urlobj->url();
267 <
268 <        # -- selection
269 <        if ( $self->{Arch} ) {
270 <          if ( $self->_autoselect() ) {
271 <             $self->{selected}{$$hashref{'name'}}=1;
272 <          }
273 <          else {
274 <             $self->{selected}{$$hashref{'name'}}=0;
275 <          }
276 <        }
277 <        $self->{creqtool}=$$hashref{'name'};
278 <        $self->{creqversion}=$$hashref{'version'};
279 <        $self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}="";
280 < }
281 <
282 < sub require_text {
283 <        my $self=shift;
284 <        my $name=shift;
285 <        my $string=shift;
286 <
287 <        chomp $string;
288 <        $self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}=
289 <                $self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}.
290 <                $string;
291 <                
292 < }
293 <
294 < sub require_end {
295 <        my $self=shift;
296 <        my $name=shift;
297 <
298 <        if ( $self->{reqcontext} != 1 ) {
299 <          $self->{switch}->parseerror("No matching tag for </$name>");
300 <        }
301 <        else {
302 <          $self->{reqcontext}=0;
303 <        }
304 < }
305 <
306 < sub select_start {
307 <        my $self=shift;
308 <        my $name=shift;
309 <        my $hashref=shift;
310 <
311 <        $self->{switch}->checktag( $name, $hashref, 'name');
312 <        $$hashref{'name'}=~tr[A-Z][a-z];
313 <        if ( $self->{Arch} ) {
314 <           $self->verbose("Selecting ".$$hashref{'name'});
315 <           $self->{selected}{$$hashref{'name'}}=1;
316 <        }
317 < }
318 <
319 < sub deselect_start {
320 <        my $self=shift;
321 <        my $name=shift;
322 <        my $hashref=shift;
323 <
324 <        $self->{switch}->checktag( $name, $hashref, 'name');
325 <        $$hashref{'name'}=~tr[A-Z][a-z];
326 <        if ( $self->{Arch} ) {
327 <           $self->verbose("Deselecting ".$$hashref{'name'});
328 <           $self->{selected}{$$hashref{'name'}}=0;
329 <        }
330 < }
331 <
332 < sub Arch_Start {
333 <        my $self=shift;
334 <        my $name=shift;
335 <        my $hashref=shift;
336 <
337 <        $self->{switch}->checktag($name, $hashref,'name');
338 <        
339 <        ( ($self->arch()=~/$$hashref{name}.*/) )? ($self->{Arch}=1)
340 <                                                : ($self->{Arch}=0);
341 <        $self->verbose(($self->{Arch}?"OK":"skipping")." ".$$hashref{name});
342 <        push @{$self->{ARCHBLOCK}}, $self->{Arch};
343 <        push @{$self->{ArchStack}}, $$hashref{'name'};
344 < }
345 <
346 < sub Arch_End {
347 <        my $self=shift;
348 <        my $name=shift;
349 <
350 <        pop @{$self->{ARCHBLOCK}};
351 <        $self->{Arch}=$self->{ARCHBLOCK}[$#{$self->{ARCHBLOCK}}];
352 < }
353 <
354 < sub disttag {
355 <        my $self=shift;
356 <        my $name=shift;
357 <        my $hashref=shift;
358 <
359 <        if ( exists $$hashref{'url'} ) {
360 <          $self->{dist}{$self->{creqtool}}{$self->{creqversion}}=
361 <                                                        $$hashref{'url'};
362 <        }
363 < }
374 > 1;

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines