From 4c1922a6e893428bfbd43bc41ff4245384d8b543 Mon Sep 17 00:00:00 2001 From: "bbaetz%student.usyd.edu.au" <> Date: Thu, 29 Aug 2002 16:25:41 +0000 Subject: Bug 163829 - move pref code into a separate package r=joel, preed --- Bugzilla/Config.pm | 379 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 379 insertions(+) create mode 100644 Bugzilla/Config.pm (limited to 'Bugzilla/Config.pm') diff --git a/Bugzilla/Config.pm b/Bugzilla/Config.pm new file mode 100644 index 000000000..76602e7ad --- /dev/null +++ b/Bugzilla/Config.pm @@ -0,0 +1,379 @@ +# -*- Mode: perl; indent-tabs-mode: nil -*- +# +# The contents of this file are subject to the Mozilla Public +# License Version 1.1 (the "License"); you may not use this file +# except in compliance with the License. You may obtain a copy of +# the License at http://www.mozilla.org/MPL/ +# +# Software distributed under the License is distributed on an "AS +# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or +# implied. See the License for the specific language governing +# rights and limitations under the License. +# +# The Original Code is the Bugzilla Bug Tracking System. +# +# The Initial Developer of the Original Code is Netscape Communications +# Corporation. Portions created by Netscape are +# Copyright (C) 1998 Netscape Communications Corporation. All +# Rights Reserved. +# +# Contributor(s): Terry Weissman +# Dawn Endico +# Dan Mosedale +# Joe Robins +# Jake +# J. Paul Reed +# Bradley Baetz +# Christopher Aillon + +package Bugzilla::Config; + +=head1 NAME + +Bugzilla::Config - Configuration paramaters for Bugzilla + +=head1 SYNOPSIS + + # Getting paramaters + use Bugzilla::Config; + + my $fooSetting = Param('foo'); + + # Administration functions + use Bugzilla::Config qw(:admin); + + my @valid_params = GetParamList(); + my @removed_params = UpgradeParams(); + SetParam($param, $value); + WriteParams(); + + # Localconfig variables may also be imported + use Bugzilla::Config qw(:db); + print "Connecting to $db_name as $db_user with $db_pass\n"; + + # These variables do not belong in localconfig, and need to go + # somewhere better + use Bugzilla::Config($contenttypes $pages) + +=head1 DESCRIPTION + +This package contains ways to access Bugzilla configuration parameters. + +=cut + +use strict; + +use base qw(Exporter); + +use Bugzilla::Util; + +# Module stuff +@Bugzilla::Config::EXPORT = qw(Param); + +# Don't export localvars by default - people should have to explicitly +# ask for it, as a (probably futile) attempt to stop code using it +# when it shouldn't +# ChmodDataFile is here until that stuff all moves out of globals.pl +# into this file +@Bugzilla::Config::EXPORT_OK = qw($contenttypes $pages ChmodDataFile); +%Bugzilla::Config::EXPORT_TAGS = + ( + admin => [qw(GetParamList UpdateParams SetParam WriteParams)], + db => [qw($db_host $db_port $db_name $db_user $db_pass)], + ); +Exporter::export_ok_tags('admin', 'db'); + +# Bugzilla version +$Bugzilla::Config::VERSION = "2.17"; + +use Data::Dumper; + +# This only has an affect for Data::Dumper >= 2.12 (ie perl >= 5.8.0) +# Its just cosmetic, though, so that doesn't matter +$Data::Dumper::Sortkeys = 1; + +use File::Temp; +use Safe; + +use vars qw(@param_list); +my %param; + +# INITIALISATION CODE + +# XXX - mod_perl - need to register Apache init handler for params +sub _load_datafiles { + # read in localconfig variables + do 'localconfig'; + + if (-e 'data/params') { + # Handle reading old param files by munging the symbol table + # Don't have to do this if we use safe mode, since its evaled + # in a sandbox where $foo is in the same module as $::foo + #local *::param = \%param; + + # Note that checksetup.pl sets file permissions on 'data/params' + + # Using Safe mode is _not_ a guarantee of safety if someone does + # manage to write to the file. However, it won't hurt... + # See bug 165144 for not needing to eval this at all + my $s = new Safe; + + $s->rdo('data/params'); + die "Error evaluating data/params: $@" if $@; + + # Now read the param back out from the sandbox + %param = %{$s->varglob('param')}; + } +} + +# Load in the datafiles +_load_datafiles(); + +# Load in the param defintions +do 'defparams.pl'; + +# Stick the params into a hash +my %params; +foreach my $item (@param_list) { + $params{$item->{'name'}} = $item; +} + +# END INIT CODE + +# Subroutines go here + +=head1 FUNCTIONS + +=head2 Parameters + +Parameters can be set, retrieved, and updated. + +=over 4 + +=item C + +Returns the Param with the specified name. Either a string, or, in the case +of multiple-choice parameters, an array reference. + +=cut + +sub Param { + my ($param) = @_; + + # By this stage, the param must be in the hash + die "Can't find param named $param" unless (exists $param{$param}); + + return $param{$param}; +} + +=item C + +Returns the list of known paramater types, from defparams.pl. Users should not +rely on this method; it is intended for editparams/doeditparams only + +The format for the list is specified in defparams.pl + +=cut + +sub GetParamList { + return @param_list; +} + +=item C + +Sets the param named $name to $value. Values are checked using the checker +function for the given param if one exists. + +=cut + +sub SetParam { + my ($name, $value) = @_; + + die "Unknown param $name" unless (exists $params{$name}); + + my $entry = $params{$name}; + + # sanity check the value + if (exists $entry->{'checker'}) { + my $err = $entry->{'checker'}->($value, $entry); + die "Param $name is not valid: $err" unless $err eq ''; + } + + $param{$name} = $value; +} + +=item C + +Updates the parameters, by transitioning old params to new formats, setting +defaults for new params, and removing obsolete ones. + +Any removed params are returned in a list, with elements [$item, $oldvalue] +where $item is the entry in the param list. + +This change is not flushed to disk, use L> for that. + +=cut + +sub UpdateParams { + # --- PARAM CONVERSION CODE --- + + # Note that this isn't particuarly 'clean' in terms of separating + # the backend code (ie this) from the actual params. + # We don't care about that, though + + # Old bugzilla versions stored the version number in the params file + # We don't want it, so get rid of it + delete $param{'version'}; + + # Change from a boolean for quips to multi-state + if (exists $param{'usequip'} && !exists $param{'allowquips'}) { + $param{'allowquips'} = $param{'usequip'} ? 'on' : 'off'; + delete $param{'usequip'}; + } + + # --- DEFAULTS FOR NEW PARAMS --- + + foreach my $item (@param_list) { + my $name = $item->{'name'}; + $param{$name} = $item->{'default'} unless exists $param{$name}; + } + + # --- REMOVE OLD PARAMS --- + + my @oldparams = (); + + # Remove any old params + foreach my $item (keys %param) { + if (!grep($_ eq $item, map ($_->{'name'}, @param_list))) { + local $Data::Dumper::Terse = 1; + local $Data::Dumper::Indent = 0; + push (@oldparams, [$item, Data::Dumper->Dump([$param{$item}])]); + delete $param{$item}; + } + } + + return @oldparams; +} + +=item C + +Writes the parameters to disk. + +=cut + +sub WriteParams { + my ($fh, $tmpname) = File::Temp::tempfile('params.XXXXX', + DIR => 'data' ); + + print $fh (Data::Dumper->Dump([ \%param ], [ '*param' ])) + || die "Can't write param file: $!"; + + close $fh; + + rename $tmpname, "data/params" + || die "Can't rename $tmpname to data/params: $!"; + + ChmodDataFile('data/params', 0666); +} + +# Some files in the data directory must be world readable iff we don't have +# a webserver group. Call this function to do this. +# This will become a private function once all the datafile handling stuff +# moves into this package + +# This sub is not perldoc'd for that reason - noone should know about it +sub ChmodDataFile { + my ($file, $mask) = @_; + my $perm = 0770; + if ((stat('data'))[2] & 0002) { + $perm = 0777; + } + $perm = $perm & $mask; + chmod $perm,$file; +} + +=back + +=head2 Parameter checking functions + +All parameter checking functions are called with two parameters: + +=over 4 + +=item * + +The new value for the parameter + +=item * + +A reference to the entry in the param list for this parameter + +=back + +Functions should return error text, or the empty string if there was no error. + +=over 4 + +=item C + +Checks that a multi-valued parameter (ie type C or type C) satisfies +its contraints. + +=cut + +sub check_multi { + my ($value, $param) = (@_); + + if ($param->{'type'} eq "s") { + unless (lsearch($param->{'choices'}, $value) >= 0) { + return "Invalid choice '$value' for single-select list param '$param'"; + } + + return ""; + } + elsif ($param->{'type'} eq "m") { + foreach my $chkParam (@$value) { + unless (lsearch($param->{'choices'}, $chkParam) >= 0) { + return "Invalid choice '$chkParam' for multi-select list param '$param'"; + } + } + + return ""; + } + else { + return "Invalid param type '$param->{'type'}' for check_multi(); " . + "contact your Bugzilla administrator"; + } +} + +=item C + +Checks that the value is a valid number + +=cut + +sub check_numeric { + my ($value) = (@_); + if ($value !~ /^[0-9]+$/) { + return "must be a numeric value"; + } + return ""; +} + +=item C + +Checks that the value is a valid regexp + +=cut + +sub check_regexp { + my ($value) = (@_); + eval { qr/$value/ }; + return $@; +} + +=back + +=cut + +1; -- cgit v1.2.3-24-g4f1b