/[cvs]/nfo/perl/libs/Data/Storage.pm
ViewVC logotype

Diff of /nfo/perl/libs/Data/Storage.pm

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.5 by joko, Tue Oct 29 19:24:18 2002 UTC revision 1.19 by joko, Tue Feb 18 19:22:11 2003 UTC
# Line 1  Line 1 
1  # $Id$  ## ------------------------------------------------------------------------
2  #  ##
3  # Copyright (c) 2002  Andreas Motl <andreas.motl@ilo.de>  ##    $Id$
4  #  ##
5  # See COPYRIGHT section in pod text below for usage and distribution rights.  ##    Copyright (c) 2002  Andreas Motl <andreas.motl@ilo.de>
6  #  ##
7  #################################  ##    See COPYRIGHT section in pod text below for usage and distribution rights.
8  #  ##
9  #  $Log$  ## ------------------------------------------------------------------------
10  #  Revision 1.5  2002/10/29 19:24:18  joko  ##
11  #  - reduced logging  ##  $Log$
12  #  + added some pod  ##  Revision 1.19  2003/02/18 19:22:11  joko
13  #  ##  + fixed logging
14  #  Revision 1.4  2002/10/27 18:35:07  joko  ##
15  #  + added pod  ##  Revision 1.18  2003/01/30 22:12:17  joko
16  #  ##  - removed/refactored old code: ->Data::Storage::Handler::Tangram|DBI
17  #  Revision 1.3  2002/10/25 11:40:37  joko  ##
18  #  + enhanced robustness  ##  Revision 1.17  2003/01/30 21:42:22  joko
19  #  + more logging for debug-levels  ##  + minor update: renamed method
20  #  + sub dropDb  ##
21  #  ##  Revision 1.16  2003/01/20 16:52:13  joko
22  #  Revision 1.2  2002/10/17 00:04:29  joko  ##  + now using 'DesignPattern::Object' to create a new 'Data::Storage::Handler::Xyz' on demand - before we did this in a hand-rolled fashion
23  #  + sub createDb  ##
24  #  + sub isConnected  ##  Revision 1.15  2003/01/19 03:12:59  joko
25  #  + bugfixes regarding "deep recursion" stuff  ##  + modified header
26  #  ##  - removed pod-documentation - now in 'Storage.pod'
27  #  Revision 1.1  2002/10/10 03:43:12  cvsjoko  ##
28  #  + new  ##  Revision 1.14  2002/12/19 16:27:59  joko
29  #  ##  - moved 'sub dropDb' to Data::Storage::Handler::DBI
30  #################################  ##
31    ##  Revision 1.13  2002/12/17 21:54:12  joko
32  # aim_V1: should encapsulate Tangram, DBI, DBD::CSV and LWP:: to access them in an unordinary way ;)  ##  + feature when using Tangram:
33  # aim_V2: introduce a generic layered structure, refactor *SUBLAYER*-stuff, make (e.g.) this possible:  ##    + what? each object created should delivered with a globally(!?) unique identifier (GUID) besides the native tangram object id (OID)
34  #               - Perl Data::Storage[DBD::CSV]  ->  Perl LWP::  ->  Internet HTTP/FTP/*  ->  Host Daemon  ->  csv-file  ##        + patched Tangram::Storage (jonen)
35    ##        + enhanced Data::Storage::Schema::Tangram (joko)
36    ##        + enhanced Data::Storage::Handler::Tangram 'sub getObjectByGuid' (jonen)
37    ##    + how?
38    ##        + each concrete (non-abstract) class gets injected with an additional field/property called 'guid' - this is done (dynamically) on schema level
39    ##        + this property ('guid') gets filled on object creation/insertion from 'sub Tangram::Storage::_insert' using Data::UUID from CPAN
40    ##        + (as for now) this property can get accessed by calling 'getObjectByGuid' on the already known storage-handle used throughout the application
41    ##
42    ##  Revision 1.12  2002/12/12 02:50:15  joko
43    ##  + this now (unfortunately) needs DBI for some helper functions
44    ##  + TODO: these have to be refactored to another scope! (soon!)
45    ##
46    ##  Revision 1.11  2002/12/11 06:53:19  joko
47    ##  + updated pod
48    ##
49    ##  Revision 1.10  2002/12/07 03:37:23  joko
50    ##  + updated pod
51    ##
52    ##  Revision 1.9  2002/12/01 22:15:45  joko
53    ##  - sub createDb: moved to handler
54    ##
55    ##  Revision 1.8  2002/11/29 04:48:23  joko
56    ##  + updated pod
57    ##
58    ##  Revision 1.7  2002/11/17 06:07:18  joko
59    ##  + creating the handler is easier than proposed first - for now :-)
60    ##  + sub testAvailability
61    ##
62    ##  Revision 1.6  2002/11/09 01:04:58  joko
63    ##  + updated pod
64    ##
65    ##  Revision 1.5  2002/10/29 19:24:18  joko
66    ##  - reduced logging
67    ##  + added some pod
68    ##
69    ##  Revision 1.4  2002/10/27 18:35:07  joko
70    ##  + added pod
71    ##
72    ##  Revision 1.3  2002/10/25 11:40:37  joko
73    ##  + enhanced robustness
74    ##  + more logging for debug-levels
75    ##  + sub dropDb
76    ##
77    ##  Revision 1.2  2002/10/17 00:04:29  joko
78    ##  + sub createDb
79    ##  + sub isConnected
80    ##  + bugfixes regarding "deep recursion" stuff
81    ##
82    ##  Revision 1.1  2002/10/10 03:43:12  cvsjoko
83    ##  + new
84    ## ------------------------------------------------------------------------
85    
86    
87  BEGIN {  BEGIN {
88  $Data::Storage::VERSION = 0.01;    $Data::Storage::VERSION = 0.03;
89  }  }
90    
   
 =head1 NAME  
   
 Data::Storage - Interface for accessing various Storage implementations for Perl in an independent way  
   
 =head1 SYNOPSIS  
   
   ... the basic way:  
   
   
   ... via inheritance:  
     
     use Data::Storage;  
     my $proxyObj = new HttpProxy;  
     $proxyObj->{url} = $url;  
     $proxyObj->{payload} = $content;  
     $self->{storage}->insert($proxyObj);  
       
     use Data::Storage;  
     my $proxyObj = HttpProxy->new(  
       url => $url,  
       payload => $content,  
     );  
     $self->{storage}->insert($proxyObj);  
   
   
 =head2 NOTE  
   
 This module heavily relies on DBI and Tangram, but adds a lot of additional bugs and quirks.  
 Please look at their documentation and this code for additional information.  
   
   
 =cut  
   
 # The POD text continues at the end of the file.  
   
   
91  package Data::Storage;  package Data::Storage;
92    
93  use strict;  use strict;
94  use warnings;  use warnings;
95    
96    use Data::Dumper;
97    # FIXME: wipe out!
98    use DBI;
99    
100  use Data::Storage::Locator;  use Data::Storage::Locator;
101    use DesignPattern::Object;
102    
103    
104    # TODO: actually implement level (integrate with Log::Dispatch)
105  my $TRACELEVEL = 0;  my $TRACELEVEL = 0;
106    
107  # get logger instance  # get logger instance
# Line 90  sub new { Line 111  sub new {
111    my $invocant = shift;    my $invocant = shift;
112    my $class = ref($invocant) || $invocant;    my $class = ref($invocant) || $invocant;
113    #my @args = normalizeArgs(@_);    #my @args = normalizeArgs(@_);
114      
115    my $arg_locator = shift;    my $arg_locator = shift;
116    my $arg_options = shift;    my $arg_options = shift;
117      #my @args = @_;
118      #@args ||= ();
119    
120      if (!$arg_locator) {
121        $logger->critical( __PACKAGE__ . "->new: No locator passed in!" );
122        return;
123      }
124        
125      #print Dumper($arg_locator);
126    
127    #my $self = { STORAGEHANDLE => undef, @_ };    #my $self = { STORAGEHANDLE => undef, @_ };
128    my $self = { STORAGEHANDLE => undef, locator => $arg_locator, options => $arg_options };    my $self = { STORAGEHANDLE => undef, locator => $arg_locator, options => $arg_options };
129    $logger->debug( __PACKAGE__ . "[$self->{locator}->{type}]" . "->new(@_)" );    #$logger->debug( __PACKAGE__ . "[$self->{locator}->{type}]" . "->new(@_)" );
130      $logger->debug( __PACKAGE__ . "[$arg_locator->{type}]" . "->new()" );
131    return bless $self, $class;    return bless $self, $class;
132  }  }
133    
# Line 107  sub AUTOLOAD { Line 138  sub AUTOLOAD {
138    #     - Deep recursion on subroutine "Data::Storage::AUTOLOAD"    #     - Deep recursion on subroutine "Data::Storage::AUTOLOAD"
139    #     - Deep recursion on subroutine "Data::Storage::Handler::Abstract::AUTOLOAD"    #     - Deep recursion on subroutine "Data::Storage::Handler::Abstract::AUTOLOAD"
140    #     - Deep recursion on anonymous subroutine at [...]    #     - Deep recursion on anonymous subroutine at [...]
141    # we also might filter log messages caused by logging itself in "advanced logging of AUTOLOAD calls"    # we also might filter log messages caused by logging to itself in "advanced logging of AUTOLOAD calls"
142        
143    my $self = shift;    my $self = shift;
144    our $AUTOLOAD;    our $AUTOLOAD;
# Line 120  sub AUTOLOAD { Line 151  sub AUTOLOAD {
151    
152    # advanced logging of AUTOLOAD calls ...    # advanced logging of AUTOLOAD calls ...
153    # ... nice but do it only when TRACING (TODO) is enabled    # ... nice but do it only when TRACING (TODO) is enabled
     if ($TRACELEVEL) {  
154        my $logstring = "";        my $logstring = "";
155        $logstring .= __PACKAGE__ . "[$self->{locator}->{type}]" . "->" . $method;        $logstring .= __PACKAGE__ . "[$self->{locator}->{type}]" . "->" . $method;
156        #print "count: ", $#_, "\n";        #print "count: ", $#_, "\n";
# Line 129  sub AUTOLOAD { Line 159  sub AUTOLOAD {
159        $logstring .= "\t" x $tabcount . "(AUTOLOAD)";        $logstring .= "\t" x $tabcount . "(AUTOLOAD)";
160        # TODO: only ok if logstring doesn't contain        # TODO: only ok if logstring doesn't contain
161        #            e.g. "Data::Storage[Tangram]->insert(SystemEvent=HASH(0x5c0034c))          (AUTOLOAD)"        #            e.g. "Data::Storage[Tangram]->insert(SystemEvent=HASH(0x5c0034c))          (AUTOLOAD)"
162        # but that would be way too specific as long as we don't have an abstract handler for this  ;)        # but that would be _way_ too specific as long as we don't have an abstract handler for this  ;)
163        if ($TRACELEVEL) {
164        $logger->debug( $logstring );        $logger->debug( $logstring );
165          #print join('; ', @_);
166      }      }
167            
168    # filtering AUTOLOAD calls    # filtering AUTOLOAD calls and first-time-touch of the actual storage impl
169    if ($self->_filter_AUTOLOAD($method)) {    if ($self->_filter_AUTOLOAD($method)) {
170      $self->_accessStorage();      #print "=== FILTER!", "\n";
171      $self->{STORAGEHANDLE}->$method(@_);      $self->_accessStorageHandle();
172        if ($self->{STORAGEHANDLE}) {
173          return $self->{STORAGEHANDLE}->$method(@_);
174        } else {
175          $logger->critical( __PACKAGE__ . "->AUTOLOAD: ERROR: " . $logstring );
176          return;
177        }
178    }    }
179        
180  }  }
# Line 153  sub _filter_AUTOLOAD { Line 191  sub _filter_AUTOLOAD {
191  }  }
192    
193    
194  sub normalizeArgs {  sub _accessStorageHandle {
   my %args = @_;  
   if (!$args{dsn} && $args{meta}{dsn}) {  
     $args{dsn} = $args{meta}{dsn};  
   }  
   my @result = %args;  
   return @result;  
 }  
   
 sub _accessStorage {  
195    my $self = shift;    my $self = shift;
196    # TODO: to some tracelevel!    # TODO: to some tracelevel!
197      #print "=========== _accessStorage", "\n";
198    if ($TRACELEVEL) {    if ($TRACELEVEL) {
199      $logger->debug( __PACKAGE__ .  "[$self->{locator}->{type}]" . "->_accessStorage()" );      $logger->debug( __PACKAGE__ .  "[$self->{locator}->{type}]" . "->_accessStorageHandle()" );
200    }    }
201    if (!$self->{STORAGEHANDLE}) {    if (!$self->{STORAGEHANDLE}) {
202      $self->_createStorageHandle();      return $self->_createStorageHandle();
203    }    }
204  }  }
205    
206  sub _createStorageHandle {  sub _createStorageHandle1 {
207    my $self = shift;    my $self = shift;
   
208    my $type = $self->{locator}->{type};    my $type = $self->{locator}->{type};
209    $logger->debug( __PACKAGE__ .  "[$type]" . "->_createStorageHandle()" );    $logger->debug( __PACKAGE__ .  "[$type]" . "->_createStorageHandle()" );
210    
211    my $pkg = "Data::Storage::Handler::" . $type . "";    my $pkg = "Data::Storage::Handler::" . $type . "";
212        
213    # propagate args to handler    # try to load perl module at runtime
214    # needs some more thoughts! (not only "dbi" to Tangram, when (in future) db is not more the common case)    my $evalstr = "use $pkg;";
215    if ($type eq 'DBI') {    eval($evalstr);
216      use Data::Storage::Handler::DBI;    if ($@) {
217      #my @args = %{$self->{locator}->{dbi}};      $logger->error( __PACKAGE__ .  "[$type]" . "->_createStorageHandle(): $@" );
218      my @args = %{$self->{locator}};      return;
     # create new storage handle  
     $self->{STORAGEHANDLE} = $pkg->new( @args );  
219    }    }
220    if ($type eq 'Tangram') {    
221      use Data::Storage::Handler::Tangram;    # build up some additional arguments to pass on
222      #$self->{STORAGEHANDLE} = $pkg->new( dsn => $self->{locator}->{dbi}->{dsn} );    #my @args = %{$self->{locator}};
223      #my @args = %{$self->{locator}->{dbi}};    my @args = ();
224      my @args = %{$self->{locator}};  
225      # create new storage handle    # - create new storage handle object
226      $self->{STORAGEHANDLE} = $pkg->new( @args );    # - propagate arguments to handler
227      # - pass locator by reference to be able to store status- or meta-information in it
228      $self->{STORAGEHANDLE} = $pkg->new( locator => $self->{locator}, @args );
229    
230    }
231    
232    sub _createStorageHandle {
233      my $self = shift;
234      my $type = $self->{locator}->{type};
235      $logger->debug( __PACKAGE__ .  "[$type]" . "->_createStorageHandle()" );
236    
237      #$self->{STORAGEHANDLE_UNDERLYING} = $self->{STORAGEHANDLE}->getUnderlyingStorage();  #print Dumper($self);
238      #$self->{STORAGEHANDLE_UNDERLYING}->_configureCOREHANDLE();  #exit;
239    
240      my $pkg = "Data::Storage::Handler::" . $type . "";
241      
242      # try to load perl module at runtime
243    =pod
244      my $evalstr = "use $pkg;";
245      eval($evalstr);
246      if ($@) {
247        $logger->error( __PACKAGE__ .  "[$type]" . "->_createStorageHandle(): $@" );
248        return;
249    }    }
250        
251      # build up some additional arguments to pass on
252      #my @args = %{$self->{locator}};
253      my @args = ();
254    
255      # - create new storage handle object
256      # - propagate arguments to handler
257      # - pass locator by reference to be able to store status- or meta-information in it
258      $self->{STORAGEHANDLE} = $pkg->new( locator => $self->{locator}, @args );
259    =cut
260    
261      $self->{STORAGEHANDLE} = DesignPattern::Object->fromPackage( $pkg, locator => $self->{locator} );
262      return 1;
263    
264  }  }
265    
266  sub addLogDispatchHandler {  sub addLogDispatchHandler {
# Line 233  sub addLogDispatchHandler { Line 292  sub addLogDispatchHandler {
292  }  }
293    
294  sub removeLogDispatchHandler {  sub removeLogDispatchHandler {
   
       my $self = shift;  
       my $name = shift;  
       #my $logger = shift;  
   
       $logger->remove($name);  
   
 }  
   
 sub getDbName {  
295    my $self = shift;    my $self = shift;
296    my $dsn = $self->{locator}->{dbi}->{dsn};    my $name = shift;
297    $dsn =~ m/database=(.+?);/;    #my $logger = shift;
298    my $database_name = $1;    $logger->remove($name);
   return $database_name;  
299  }  }
300    
 sub testDsn {  
   my $self = shift;  
   my $dsn = $self->{locator}->{dbi}->{dsn};  
   my $result;  
   if ( my $dbh = DBI->connect($dsn, '', '', {  
                                                       PrintError => 0,  
                                                       } ) ) {  
     $dbh->disconnect();  
     return 1;  
   } else {  
     $logger->error( __PACKAGE__ .  "[$self->{locator}->{type}]" . "->testDsn(): " . "DBI-error: " . $DBI::errstr );  
   }  
 }  
   
 sub createDb {  
   my $self = shift;  
   my $dsn = $self->{locator}->{dbi}->{dsn};  
   
   $logger->debug( __PACKAGE__ .  "->createDb( dsn $dsn )" );  
   
   $dsn =~ s/database=(.+?);//;  
   my $database_name = $1;  
   
   my $ok;  
     
   if ( my $dbh = DBI->connect($dsn, '', '', {  
                                                       PrintError => 0,  
                                                       } ) ) {  
     if ($database_name) {  
       if ($dbh->do("CREATE DATABASE $database_name;")) {  
         $ok = 1;  
       }  
     }  
     $dbh->disconnect();  
   }  
     
   return $ok;  
     
 }  
   
 sub dropDb {  
   my $self = shift;  
   my $dsn = $self->{locator}->{dbi}->{dsn};  
   
   $logger->debug( __PACKAGE__ .  "->dropDb( dsn $dsn )" );  
   
   $dsn =~ s/database=(.+?);//;  
   my $database_name = $1;  
   
   my $ok;  
     
   if ( my $dbh = DBI->connect($dsn, '', '', {  
                                                       PrintError => 0,  
                                                       } ) ) {  
     if ($database_name) {  
       if ($dbh->do("DROP DATABASE $database_name;")) {  
         $ok = 1;  
       }  
     }  
     $dbh->disconnect();  
   }  
     
   return $ok;  
 }  
   
 sub isConnected {  
   my $self = shift;  
   return 1 if $self->{STORAGEHANDLE};  
 }  
301    
302  1;  1;
303  __END__  __END__
   
   
 =head1 DESCRIPTION  
   
 Data::Storage is module for a accessing various "data structures" stored inside  
 various "data containers". It sits on top of DBI and/or Tangram.  
   
   
 =head1 AUTHORS / COPYRIGHT  
   
 The Data::Storage module is Copyright (c) 2002 Andreas Motl.  
 All rights reserved.  
   
 You may distribute it under the terms of either the GNU General Public  
 License or the Artistic License, as specified in the Perl README file.  
   
   
 =head1 ACKNOWLEDGEMENTS  
   
 Larry Wall and the C<perl5-porters> for Perl,  
 Tim Bunce for DBI, Jean-Louis Leroy for Tangram and Set::Object,  
 Sam Vilain for Class::Tangram.  
   
   
 =head1 SUPPORT / WARRANTY  
   
 Data::Storage is free software. IT COMES WITHOUT WARRANTY OF ANY KIND.  
   
   
 =head1 TODO  
   
   
 =head2 Handle the following errors/cases:  
   
 =head3 "DBI-Error [Tangram]: DBD::mysql::st execute failed: Unknown column 't1.requestdump' in 'field list'"  
   
     ... occours when operating on object-attributes not introduced yet:  
     this should be detected and appended/replaced through:  
     "Schema-Error detected, maybe (just) an inconsistency.  
     Please check if your declaration in schema-module "a" matches structure in database "b" or try to run"  
     db_setup.pl --dbkey=import --action=deploy  
   
 =head3 Compare schema (structure diff) with database ...  
   
   ... when issuing "db_setup.pl --dbkey=import --action=deploy"  
   on a database with an already deployed schema, use an additional "--update" then  
   to lift the schema inside the database to the current declared schema.  
   You will have to approve removals and changes on field-level while  
   new objects and new fields are introduced silently without any interaction needed.  
   In future versions there may be additional options to control silent processing of  
   removals and changes.  
   See this CRUD-table applying to the actions occouring on Classes and Class variables when deploying schemas,  
   don't mix this up with CRUD-actions on Objects, these are already handled by (e.g.) Tangram itself.  
   Classes:  
     C create    ->  yes, handled automatically  
     R retrieve  ->  no, not subject of this aspect since it is about deployment only  
     U update    ->  yes, automatically for Class meta-attributes, yes/no for Class variables (look at the rules down here)  
     D delete    ->  yes, just by user-interaction  
   Class variables:  
     C create    ->  yes, handled automatically  
     R retrieve  ->  no, not subject of this aspect since it is about deployment only  
     U update    ->  yes, just by user-interaction; maybe automatically if it can be determined that data wouldn't be lost  
     D delete    ->  yes, just by user-interaction  
     
   It's all about not to be able to loose data simply while this is in pre-alpha stage.  
   And loosing data by being able to modify and redeploy schemas easily is definitely quite easy.  
     
   As we can see, creations of Classes and new Class variables is handled  
   automatically and this is believed to be the most common case under normal circumstances.  
   
   
 =head2 Introduce some features:  
   
   - Get this stuff together with UML (Unified Modeling Language) and/or standards from ODMG.  
   - Make it possible to load/save schemas in XMI (XML Metadata Interchange),  
     which seems to be most commonly used today, perhaps handle objects with OIFML.  
     Integrate/bundle this with a web-/html-based UML modeling tool or  
     some other interesting stuff like the "Co-operative UML Editor" from Uni Darmstadt. (web-/java-based)  
   - Enable Round Trip Engineering. Keep code and diagrams in sync. Don't annoy/bother the programmers.  
   - Add some more handlers:  
     - look at DBD::CSV, Text::CSV, XML::CSV, XML::Excel  
   - Add some more locations/locators:  
     - PerlDAV: http://www.webdav.org/perldav/  
   - Move to t3, use InCASE  
   
   
 =head3 Links:  
   
   Specs:  
     UML 1.3 Spec: http://cgi.omg.org/cgi-bin/doc?ad/99-06-08.pdf  
     XMI 1.1 Spec: http://cgi.omg.org/cgi-bin/doc?ad/99-10-02.pdf  
     XMI 2.0 Spec: http://cgi.omg.org/docs/ad/01-06-12.pdf  
     ODMG: http://odmg.org/  
     OIFML: http://odmg.org/library/readingroom/oifml.pdf  
   
   CASE Tools:  
     Rational Rose (commercial): http://www.rational.com/products/rose/  
     Together (commercial): http://www.oi.com/products/controlcenter/index.jsp  
     InCASE - Tangram-based Universal Object Editor  
     Sybase PowerDesigner: http://www.sybase.com/powerdesigner  
     
   UML Editors:  
     Fujaba (free, university): http://www.fujaba.de/  
     ArgoUML (free): http://argouml.tigris.org/  
     Poseidon (commercial): http://www.gentleware.com/products/poseidonDE.php3  
     Co-operative UML Editor (research): http://www.darmstadt.gmd.de/concert/activities/internal/umledit.html  
     Metamill (commercial): http://www.metamill.com/  
     Violet (university, research, education): http://www.horstmann.com/violet/  
     PyUt (free): http://pyut.sourceforge.net/  
     (Dia (free): http://www.lysator.liu.se/~alla/dia/)  
     UMLet (free, university): http://www.swt.tuwien.ac.at/umlet/index.html  
     Voodoo (free): http://voodoo.sourceforge.net/  
   
   UML Tools:  
     http://www.objectsbydesign.com/tools/umltools_byPrice.html  
   
   Further readings:  
     http://www.google.com/search?q=web+based+uml+editor&hl=en&lr=&ie=UTF-8&oe=UTF-8&start=10&sa=N  
     http://www.fernuni-hagen.de/DVT/Aktuelles/01FHHeidelberg.pdf  
     http://www.enhyper.com/src/documentation/  
     http://cis.cs.tu-berlin.de/Dokumente/Diplomarbeiten/2001/skinner.pdf  
     http://citeseer.nj.nec.com/vilain00diagrammatic.html  
     http://archive.devx.com/uml/articles/Smith01/Smith01-3.asp  
   
Legend:
Removed from v.1.5  
changed lines
  Added in v.1.19
MailToCvsAdmin">MailToCvsAdmin
 ViewVC Help
Powered by ViewVC 1.1.26 RSS 2.0 feed