| #************************************************************** |
| # |
| # Licensed to the Apache Software Foundation (ASF) under one |
| # or more contributor license agreements. See the NOTICE file |
| # distributed with this work for additional information |
| # regarding copyright ownership. The ASF licenses this file |
| # to you under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, |
| # software distributed under the License is distributed on an |
| # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| # KIND, either express or implied. See the License for the |
| # specific language governing permissions and limitations |
| # under the License. |
| # |
| #************************************************************** |
| |
| |
| |
| #************************************************************************* |
| # |
| # SourceConfig - Perl extension for parsing general info databases |
| # |
| # usage: see below |
| # |
| #************************************************************************* |
| |
| package SourceConfig; |
| |
| use strict; |
| |
| use constant SOURCE_CONFIG_FILE_NAME => 'source_config'; |
| use constant SOURCE_CONFIG_VERSION => 3; |
| |
| use Carp; |
| use Cwd; |
| use RepositoryHelper; |
| use File::Basename; |
| use File::Temp qw(tmpnam); |
| |
| my $debug = 0; |
| |
| ##### profiling ##### |
| |
| ##### ctor ##### |
| |
| sub new { |
| my $proto = shift; |
| my $class = ref($proto) || $proto; |
| my $source_root = shift; |
| my @additional_repositories = @_; |
| |
| my $self = {}; |
| $self->{USER_SOURCE_ROOT} = undef; |
| $self->{SOURCE_CONFIG_FILE} = undef; |
| if (defined $source_root) { |
| $source_root = Cwd::realpath($source_root); |
| $source_root =~ s/\\|\/$//; |
| if (-f $source_root) { |
| # We have path to source_config |
| if (File::Basename::basename($source_root) eq 'source_config') { |
| # We have path to source_config |
| $self->{SOURCE_CONFIG_FILE} = $source_root; |
| $source_root = File::Basename::dirname($source_root); |
| } else { |
| croak("$source_root is not a source_config file"); |
| }; |
| } else { |
| $self->{USER_SOURCE_ROOT} = $source_root; |
| $source_root .= '/..'; |
| } |
| } else { |
| $source_root = $ENV{SOURCE_ROOT_DIR}; |
| }; |
| $source_root = Cwd::realpath($source_root); |
| $self->{SOURCE_ROOT} = $source_root; |
| $self->{DEBUG} = 0; |
| $self->{VERBOSE} = 0; |
| $self->{REPOSITORIES} = {}; |
| $self->{ACTIVATED_REPOSITORIES} = {}; |
| $self->{MODULE_PATHS} = {}; |
| $self->{MODULE_BUILD_LIST_PATHS} = {}; |
| $self->{ACTIVATED_MODULES} = {}; |
| $self->{MODULE_REPOSITORY} = {}; |
| $self->{REAL_MODULES} = {}; |
| $self->{NEW_MODULES} = []; |
| $self->{REMOVE_MODULES} = {}; |
| $self->{REMOVE_REPOSITORIES} = {}; |
| $self->{NEW_REPOSITORIES} = []; |
| $self->{WARNINGS} = []; |
| $self->{REPORT_MESSAGES} = []; |
| $self->{CONFIG_FILE_CONTENT} = []; |
| if (defined $self->{USER_SOURCE_ROOT}) { |
| ${$self->{REPOSITORIES}}{File::Basename::basename($self->{USER_SOURCE_ROOT})} = $self->{USER_SOURCE_ROOT}; |
| }; |
| $self->{SOURCE_CONFIG_FILE} = get_config_file($self->{SOURCE_ROOT}) if (!defined $self->{SOURCE_CONFIG_FILE}); |
| $self->{SOURCE_CONFIG_DEFAULT} = $self->{SOURCE_ROOT} .'/'.SOURCE_CONFIG_FILE_NAME; |
| if (defined $self->{USER_SOURCE_ROOT}) { |
| ${$self->{REPOSITORIES}}{File::Basename::basename($self->{USER_SOURCE_ROOT})} = $self->{USER_SOURCE_ROOT}; |
| }; |
| foreach my $additional_repository (@additional_repositories) |
| { |
| ${$self->{REPOSITORIES}}{File::Basename::basename($additional_repository)} = $additional_repository; |
| } |
| |
| read_config_file($self); |
| get_module_paths($self); |
| bless($self, $class); |
| return $self; |
| } |
| |
| ##### methods ##### |
| |
| sub get_version { |
| return SOURCE_CONFIG_VERSION; |
| }; |
| |
| sub get_repositories |
| { |
| my $self = shift; |
| return sort keys %{$self->{REPOSITORIES}}; |
| } |
| |
| sub add_repository |
| { |
| my $self = shift; |
| my $new_rep_path = shift; |
| $new_rep_path = Cwd::realpath($new_rep_path); |
| my $new_rep_name = File::Basename::basename($new_rep_path); |
| if (defined ${$self->{REPOSITORIES}}{$new_rep_name}) { |
| croak("Repository $new_rep_name is already defined!!"); |
| }; |
| ${$self->{REPOSITORIES}}{$new_rep_name} = $new_rep_path; |
| $self -> get_repository_module_paths($new_rep_name); |
| } |
| |
| sub get_config_file_default_path { |
| my $self = shift; |
| return $self->{SOURCE_CONFIG_DEFAULT}; |
| } |
| |
| sub get_config_file_path { |
| my $self = shift; |
| return $self->{SOURCE_CONFIG_FILE}; |
| } |
| |
| sub get_module_repository { |
| my $self = shift; |
| my $module = shift; |
| if (defined ${$self->{MODULE_REPOSITORY}}{$module}) { |
| return ${$self->{MODULE_REPOSITORY}}{$module}; |
| } else { |
| Carp::cluck("No such module $module in active repositories!!\n"); |
| return undef; |
| }; |
| } |
| |
| sub get_module_path { |
| my $self = shift; |
| my $module = shift; |
| if (defined ${$self->{MODULE_PATHS}}{$module}) { |
| return ${$self->{MODULE_PATHS}}{$module}; |
| } else { |
| Carp::cluck("No path for module $module in active repositories!!\n") if ($debug); |
| return undef; |
| }; |
| } |
| |
| sub get_module_build_list { |
| my $self = shift; |
| my $module = shift; |
| if (defined ${$self->{MODULE_BUILD_LIST_PATHS}}{$module}) { |
| return ${$self->{MODULE_BUILD_LIST_PATHS}}{$module}; |
| } else { |
| my @possible_build_lists = ('build.lst', 'build.xlist'); # build lists names |
| foreach (@possible_build_lists) { |
| my $possible_path = ${$self->{MODULE_PATHS}}{$module} . "/prj/$_"; |
| if (-e $possible_path) { |
| ${$self->{MODULE_BUILD_LIST_PATHS}}{$module} = $possible_path; |
| return $possible_path; |
| }; |
| }; |
| Carp::cluck("No build list in module $module found!!\n") if ($self->{DEBUG}); |
| return undef; |
| }; |
| } |
| |
| sub get_all_modules |
| { |
| my $self = shift; |
| my $module = shift; |
| return sort keys %{$self->{MODULE_PATHS}}; |
| }; |
| |
| sub get_active_modules |
| { |
| my $self = shift; |
| if (scalar keys %{$self->{ACTIVATED_MODULES}}) { |
| return sort keys %{$self->{ACTIVATED_MODULES}}; |
| } |
| return sort keys %{$self->{REAL_MODULES}}; |
| } |
| |
| sub is_active |
| { |
| my $self = shift; |
| my $module = shift; |
| if (scalar keys %{$self->{ACTIVATED_MODULES}}) { |
| return exists ($self->{ACTIVATED_MODULES}{$module}); |
| } |
| return exists ($self->{REAL_MODULES}{$module}); |
| } |
| |
| ##### private methods ##### |
| |
| sub get_repository_module_paths { |
| my $self = shift; |
| my $repository = shift; |
| my $repository_path = ${$self->{REPOSITORIES}}{$repository}; |
| if (opendir DIRHANDLE, $repository_path) { |
| foreach my $module (readdir(DIRHANDLE)) { |
| next if (($module =~ /^\.+/) || (!-d "$repository_path/$module")); |
| my $module_entry = $module; |
| if (($module !~ s/\.lnk$//) && ($module !~ s/\.link$//)) { |
| $self->{REAL_MODULES}{$module}++; |
| } |
| my $possible_path = "$repository_path/$module_entry"; |
| if (-d $possible_path) { |
| if (defined ${$self->{MODULE_PATHS}}{$module}) { |
| close DIRHANDLE; |
| croak("Ambiguous paths for module $module: $possible_path and " . ${$self->{MODULE_PATHS}}{$module}); |
| }; |
| ${$self->{MODULE_PATHS}}{$module} = $possible_path; |
| ${$self->{MODULE_REPOSITORY}}{$module} = $repository; |
| } |
| }; |
| close DIRHANDLE; |
| } else { |
| croak("Cannot read $repository_path repository content"); |
| }; |
| }; |
| |
| sub get_module_paths { |
| my $self = shift; |
| foreach my $repository (keys %{$self->{REPOSITORIES}}) { |
| get_repository_module_paths($self, $repository); |
| }; |
| my @false_actives = (); |
| foreach (keys %{$self->{ACTIVATED_MODULES}}) { |
| push(@false_actives, $_) if (!defined ${$self->{MODULE_PATHS}}{$_}); |
| }; |
| croak("Error!! Activated module(s): @false_actives\nnot found in the active repositories!! Please check your " . $self->{SOURCE_CONFIG_FILE} . "\n") if (scalar @false_actives); |
| croak("No modules found!") if (!scalar keys %{$self->{MODULE_PATHS}}); |
| }; |
| |
| sub get_config_file { |
| my $source_root = shift; |
| my $possible_path = $source_root . '/' . SOURCE_CONFIG_FILE_NAME; |
| return $possible_path if (-f $possible_path); |
| return ''; |
| }; |
| |
| # |
| # Fallback - fallback repository is based on RepositoryHelper educated guess |
| # |
| sub get_fallback_repository { |
| my $self = shift; |
| my $repository_root = RepositoryHelper->new()->get_repository_root(); |
| ${$self->{REPOSITORIES}}{File::Basename::basename($repository_root)} = $repository_root; |
| }; |
| |
| sub read_config_file { |
| my $self = shift; |
| if (!$self->{SOURCE_CONFIG_FILE}) { |
| if (!defined $self->{USER_SOURCE_ROOT}) { |
| get_fallback_repository($self); |
| }; |
| return; |
| }; |
| my $repository_section = 0; |
| my $module_section = 0; |
| my $line = 0; |
| my @file_content = (); |
| |
| if (open(SOURCE_CONFIG_FILE, $self->{SOURCE_CONFIG_FILE})) { |
| foreach (<SOURCE_CONFIG_FILE>) { |
| push (@{$self->{CONFIG_FILE_CONTENT}}, $_); |
| $line++; |
| chomp; |
| next if (!/^\S+/); |
| next if (/^\s*#+/); |
| s/\r\n//; |
| if (/^\[repositories\]\s*(\s+#)*/) { |
| $module_section = 0; |
| $repository_section = 1; |
| next; |
| }; |
| if (/^\[modules\]\s*(\s+#)*/) { |
| $module_section = 1; |
| $repository_section = 0; |
| next; |
| }; |
| next if (!$repository_section && !$module_section); |
| if (/\s*(\S+)=active\s*(\s+#)*/) { |
| if ($repository_section) { |
| my $repository_source_path = $self->{SOURCE_ROOT} . "/$1"; |
| if (defined $ENV{UPDMINOREXT}) { |
| $repository_source_path .= $ENV{UPDMINOREXT}; |
| if (defined ${$self->{REPOSITORIES}}{$1.$ENV{UPDMINOREXT}}) { |
| delete ${$self->{REPOSITORIES}}{$1.$ENV{UPDMINOREXT}}; |
| }; |
| }; |
| ${$self->{REPOSITORIES}}{$1} = $repository_source_path; |
| ${$self->{ACTIVATED_REPOSITORIES}}{$1}++; |
| next; |
| } |
| if ($module_section) { |
| ${$self->{ACTIVATED_MODULES}}{$1}++; |
| next; |
| }; |
| }; |
| croak("Line $line in " . $self->{SOURCE_CONFIG_FILE} . ' violates format. Please make your checks!'); |
| }; |
| close SOURCE_CONFIG_FILE; |
| if (!scalar keys %{$self->{REPOSITORIES}}) { |
| get_fallback_repository($self); |
| }; |
| } else { |
| croak('Cannot open ' . $self->{SOURCE_CONFIG_FILE} . ' for reading'); |
| }; |
| }; |
| |
| sub remove_all_activated_repositories { |
| my $self = shift; |
| $self->remove_activated_repositories([keys %{$self->{ACTIVATED_REPOSITORIES}}]); |
| }; |
| |
| sub remove_activated_repositories { |
| my $self = shift; |
| my $new_repositories_ref = shift; |
| push(@{$self->{WARNINGS}}, "\nWARNING: Empty repository list passed for removing from source_config\n") if (!scalar @$new_repositories_ref); |
| $self->{VERBOSE} = shift; |
| $self->{REMOVE_REPOSITORIES} = {}; |
| foreach (@$new_repositories_ref) { |
| if (!defined ${$self->{ACTIVATED_REPOSITORIES}}{$_}) { |
| push (@{$self->{WARNINGS}}, "\nWARNING: repository $_ is not activated in ". $self->get_config_file_default_path()."\n"); |
| } else { |
| ${$self->{REMOVE_REPOSITORIES}}{$_}++; |
| delete ${$self->{ACTIVATED_REPOSITORIES}}{$_}; |
| }; |
| }; |
| generate_config_file($self); |
| }; |
| |
| sub remove_all_activated_modules { |
| my $self = shift; |
| $self->remove_activated_modules([keys %{$self->{ACTIVATED_MODULES}}]); |
| }; |
| |
| sub remove_activated_modules { |
| my $self = shift; |
| my $new_modules_ref = shift; |
| push(@{$self->{WARNINGS}}, "\nWARNING: Empty module list passed for removing from source_config\n") if (!scalar @$new_modules_ref); |
| $self->{VERBOSE} = shift; |
| $self->{REMOVE_MODULES} = {}; |
| foreach (@$new_modules_ref) { |
| if (!defined ${$self->{ACTIVATED_MODULES}}{$_}) { |
| push (@{$self->{WARNINGS}}, "\nWARNING: module $_ is not activated in ". $self->get_config_file_default_path()."\n"); |
| } else { |
| ${$self->{REMOVE_MODULES}}{$_}++; |
| delete ${$self->{ACTIVATED_MODULES}}{$_}; |
| }; |
| }; |
| generate_config_file($self); |
| }; |
| |
| sub add_active_repositories { |
| my $self = shift; |
| $self->{NEW_REPOSITORIES} = shift; |
| croak('Empty repository list passed for addition to source_config') if (!scalar @{$self->{NEW_REPOSITORIES}}); |
| $self->{VERBOSE} = shift; |
| foreach (@{$self->{NEW_REPOSITORIES}}) { |
| $self->add_repository($_); |
| }; |
| generate_config_file($self); |
| }; |
| |
| sub add_active_modules { |
| my $self = shift; |
| my $module_list_ref = shift; |
| my $ignored_modules_string = ''; |
| my @real_modules = (); |
| foreach my $module (sort @$module_list_ref) { |
| if ($self->get_module_path($module)) { |
| push(@real_modules, $module); |
| } else { |
| $ignored_modules_string .= " $module"; |
| }; |
| }; |
| push (@{$self->{WARNINGS}}, "\nWARNING: following modules are not found in active repositories, and have not been added to the " . $self->get_config_file_default_path() . ":$ignored_modules_string\n") if ($ignored_modules_string); |
| $self->{NEW_MODULES} = \@real_modules; |
| croak('Empty module list passed for addition to source_config') if (!scalar @{$self->{NEW_MODULES}}); |
| $self->{VERBOSE} = shift; |
| generate_config_file($self); |
| }; |
| |
| sub add_content { |
| my $self = shift; |
| my $content = shift; |
| my $entries_to_add = shift; |
| return if (!scalar @$entries_to_add); |
| my $message; |
| my $message_part1; |
| my $warning_message; |
| my $activated_entries; |
| |
| if ($entries_to_add == $self->{NEW_MODULES}) { |
| $self->{NEW_MODULES} = []; |
| $message_part1 = "Module(s):\n"; |
| $activated_entries = $self->{ACTIVATED_MODULES}; |
| } elsif ($entries_to_add == $self->{NEW_REPOSITORIES}) { |
| $self->{NEW_REPOSITORIES} = []; |
| $message_part1 = "Repositories:\n"; |
| $activated_entries = $self->{ACTIVATED_REPOSITORIES}; |
| }; |
| foreach my $entry (@$entries_to_add) { |
| if (defined $$activated_entries{$entry}) { |
| $warning_message .= "$entry " |
| } else { |
| push(@$content, "$entry=active\n"); |
| ${$activated_entries}{$entry}++; |
| $message .= "$entry " |
| }; |
| }; |
| |
| push(@{$self->{REPORT_MESSAGES}}, "\n$message_part1 $message\nhave been added to the ". $self->get_config_file_default_path()."\n") if ($message); |
| push (@{$self->{WARNINGS}}, "\nWARNING: $message_part1 $warning_message\nare already added to the ". $self->get_config_file_default_path()."\n") if ($warning_message); |
| }; |
| |
| sub generate_config_file { |
| my $self = shift; |
| my @config_content_new = (); |
| my ($module_section, $repository_section); |
| my %removed_modules = (); |
| my %removed_repositories = (); |
| foreach (@{$self->{CONFIG_FILE_CONTENT}}) { |
| if (/^\[repositories\]\s*(\s+#)*/) { |
| if ($module_section) { |
| $self->add_content(\@config_content_new, $self->{NEW_MODULES}); |
| }; |
| $module_section = 0; |
| $repository_section = 1; |
| }; |
| if (/^\[modules\]\s*(\s+#)*/) { |
| if ($repository_section) { |
| $self->add_content(\@config_content_new, $self->{NEW_REPOSITORIES}); |
| }; |
| $module_section = 1; |
| $repository_section = 0; |
| }; |
| if ($module_section && /\s*(\S+)=active\s*(\s+#)*/) { |
| if (defined ${$self->{REMOVE_MODULES}}{$1}) { |
| $removed_modules{$1}++; |
| next; |
| }; |
| } |
| if ($repository_section && /\s*(\S+)=active\s*(\s+#)*/) { |
| if (defined ${$self->{REMOVE_REPOSITORIES}}{$1}) { |
| $removed_repositories{$1}++; |
| next; |
| }; |
| } |
| push(@config_content_new, $_); |
| }; |
| if (scalar @{$self->{NEW_MODULES}}) { |
| push(@config_content_new, "[modules]\n") if (!$module_section); |
| $self->add_content(\@config_content_new, $self->{NEW_MODULES}); |
| }; |
| if (scalar @{$self->{NEW_REPOSITORIES}}) { |
| push(@config_content_new, "[repositories]\n") if (!$repository_section); |
| $self->add_content(\@config_content_new, $self->{NEW_REPOSITORIES}); |
| }; |
| if (scalar keys %removed_modules) { |
| my @deleted_modules = keys %removed_modules; |
| push(@{$self->{REPORT_MESSAGES}}, "\nModules: @deleted_modules\nhave been removed from the ". $self->get_config_file_default_path()."\n"); |
| |
| }; |
| if (scalar keys %removed_repositories) { |
| my @deleted_repositories = keys %removed_repositories; |
| push(@{$self->{REPORT_MESSAGES}}, "\nRepositories: @deleted_repositories\nhave been removed from the ". $self->get_config_file_default_path()."\n"); |
| |
| }; |
| |
| # Writing file, printing warnings and reports |
| |
| #check if we need to write a new file |
| my $write_needed = 0; |
| if ((scalar @{$self->{CONFIG_FILE_CONTENT}}) != (scalar @config_content_new)) { |
| $write_needed++; |
| } else { |
| foreach my $i (0 .. $#{$self->{CONFIG_FILE_CONTENT}}) { |
| if (${$self->{CONFIG_FILE_CONTENT}}[$i] ne $config_content_new[$i]) { |
| $write_needed++; |
| last; |
| }; |
| }; |
| }; |
| if ($write_needed) { |
| my $temp_config_file = File::Temp::tmpnam($ENV{TMP}); |
| die("Cannot open $temp_config_file") if (!open(NEW_CONFIG, ">$temp_config_file")); |
| print NEW_CONFIG $_ foreach (@config_content_new); |
| close NEW_CONFIG; |
| rename($temp_config_file, $self->get_config_file_default_path()) or system("mv", $temp_config_file, $self->get_config_file_default_path()); |
| if (-e $temp_config_file) { |
| system("rm -rf $temp_config_file") if (!unlink $temp_config_file); |
| }; |
| $self->{CONFIG_FILE_CONTENT} = \@config_content_new; |
| }; |
| if ($self->{VERBOSE}) { |
| print $_ foreach (@{$self->{WARNINGS}}); |
| $self->{VERBOSE} = 0; |
| }; |
| $self->{WARNINGS} = []; |
| print $_ foreach (@{$self->{REPORT_MESSAGES}}); |
| $self->{REPORT_MESSAGES} = []; |
| }; |
| |
| ##### finish ##### |
| |
| 1; # needed by use or require |
| |
| __END__ |
| |
| =head1 NAME |
| |
| SourceConfig - Perl extension for parsing general info databases |
| |
| =head1 SYNOPSIS |
| |
| # example that will read source_config file and return the active repositories |
| |
| use SourceConfig; |
| |
| # Create a new instance of the parser: |
| $a = SourceConfig->new(); |
| |
| # Get repositories for the actual workspace: |
| $a->get_repositories(); |
| |
| # Add a repository new_repository for the actual workspace (via full path): |
| $a->add_repository(/DEV300/new_repository); |
| |
| =head1 DESCRIPTION |
| |
| SourceConfig is a perl extension to load and parse General Info Databses. |
| It uses a simple object oriented interface to retrieve the information stored |
| in the database. |
| |
| Methods: |
| |
| SourceConfig::new() |
| |
| Creates a new instance of SourceConfig. Can be initialized by: path to the default repository, path to the source_config, default - empty, the source_config will be taken from the environment |
| |
| |
| SourceConfig::get_version() |
| |
| Returns version number of the module. Can't fail. |
| |
| |
| SourceConfig::get_repositories() |
| |
| Returns sorted list of active repositories for the actual workspace |
| |
| |
| SourceConfig::add_repository(REPOSITORY_PATH) |
| |
| Adds a repository to the list of active repositories |
| |
| |
| SourceConfig::get_active_modules() |
| |
| Returns a sorted list of active modules |
| |
| SourceConfig::get_all_modules() |
| |
| Returns sorted list of all modules in active repositories. |
| |
| SourceConfig::get_module_path($module) |
| |
| Returns absolute module path |
| |
| SourceConfig::get_module_build_list($module) |
| |
| Returns absolute module build list path |
| |
| SourceConfig::get_module_repository($module) |
| |
| Returns the module's repository |
| |
| SourceConfig::get_config_file_path() |
| |
| Returns absolute module to the source configuration file |
| |
| SourceConfig::get_config_file_default_path() |
| |
| Returns default path for source configuration file |
| |
| SourceConfig::is_active() |
| |
| Returns 1 (TRUE) if a module is active |
| Returns 0 (FALSE) if a module is not active |
| |
| SourceConfig::add_active_modules($module_array_ref) |
| |
| Adds modules from the @$module_array_ref as active to the source_config file |
| |
| SourceConfig::add_active_repositories($repository_array_ref) |
| |
| Adds repositories from the @$repository_array_ref as active to the source_config file |
| |
| SourceConfig::remove_activated_modules($module_array_ref) |
| |
| Removes modules from the @$module_array_ref from the source_config file |
| |
| SourceConfig::remove_all_activated_modules() |
| |
| Removes all activated modules from the source_config file |
| |
| SourceConfig::remove_activated_repositories($repository_array_ref) |
| |
| Removes repositories from the @$repository_array_ref from the source_config file |
| |
| SourceConfig::remove_all_activated_repositories() |
| |
| Removes all activated repositories from the source_config file |
| |
| |
| =head2 EXPORT |
| |
| SourceConfig::new() |
| SourceConfig::get_version() |
| SourceConfig::get_repositories() |
| SourceConfig::add_repository() |
| SourceConfig::get_active_modules() |
| SourceConfig::get_all_modules() |
| SourceConfig::get_module_path($module) |
| SourceConfig::get_module_build_list($module) |
| SourceConfig::get_module_repository($module) |
| SourceConfig::get_config_file_path() |
| SourceConfig::get_config_file_default_path() |
| SourceConfig::is_active($module) |
| SourceConfig::add_active_modules($module_array_ref) |
| SourceConfig::add_active_repositories($repository_array_ref) |
| SourceConfig::remove_activated_modules($module_array_ref) |
| SourceConfig::remove_all_activated_modules() |
| SourceConfig::remove_activated_repositories($repository_array_ref) |
| SourceConfig::remove_all_activated_repositories() |
| |
| =head1 AUTHOR |
| |
| Vladimir Glazunov, vg@openoffice.org |
| |
| =head1 SEE ALSO |
| |
| perl(1). |
| |
| =cut |