| # This Source Code Form is subject to the terms of the Mozilla Public |
| # License, v. 2.0. If a copy of the MPL was not distributed with this |
| # file, You can obtain one at http://mozilla.org/MPL/2.0/. |
| # |
| # This Source Code Form is "Incompatible With Secondary Licenses", as |
| # defined by the Mozilla Public License, v. 2.0. |
| |
| package Bugzilla::Install; |
| |
| # Functions in this this package can assume that the database |
| # has been set up, params are available, localconfig is |
| # available, and any module can be used. |
| # |
| # If you want to write an installation function that can't |
| # make those assumptions, then it should go into one of the |
| # packages under the Bugzilla::Install namespace. |
| |
| use 5.10.1; |
| use strict; |
| use warnings; |
| |
| use Bugzilla::Component; |
| use Bugzilla::Config qw(:admin); |
| use Bugzilla::Constants; |
| use Bugzilla::Error; |
| use Bugzilla::Group; |
| use Bugzilla::Product; |
| use Bugzilla::User; |
| use Bugzilla::User::Setting; |
| use Bugzilla::Util qw(get_text); |
| use Bugzilla::Version; |
| |
| use constant STATUS_WORKFLOW => ( |
| [undef, 'UNCONFIRMED'], |
| [undef, 'CONFIRMED'], |
| [undef, 'IN_PROGRESS'], |
| ['UNCONFIRMED', 'CONFIRMED'], |
| ['UNCONFIRMED', 'IN_PROGRESS'], |
| ['UNCONFIRMED', 'RESOLVED'], |
| ['CONFIRMED', 'IN_PROGRESS'], |
| ['CONFIRMED', 'RESOLVED'], |
| ['IN_PROGRESS', 'CONFIRMED'], |
| ['IN_PROGRESS', 'RESOLVED'], |
| ['RESOLVED', 'UNCONFIRMED'], |
| ['RESOLVED', 'CONFIRMED'], |
| ['RESOLVED', 'VERIFIED'], |
| ['VERIFIED', 'UNCONFIRMED'], |
| ['VERIFIED', 'CONFIRMED'], |
| ); |
| |
| sub SETTINGS { |
| return { |
| # 2005-03-03 travis@sedsystems.ca -- Bug 41972 |
| display_quips => { options => ["on", "off"], default => "on" }, |
| # 2005-03-10 travis@sedsystems.ca -- Bug 199048 |
| comment_sort_order => { options => ["oldest_to_newest", "newest_to_oldest", |
| "newest_to_oldest_desc_first"], |
| default => "oldest_to_newest" }, |
| # 2005-05-12 bugzilla@glob.com.au -- Bug 63536 |
| post_bug_submit_action => { options => ["next_bug", "same_bug", "nothing"], |
| default => "next_bug" }, |
| # 2005-06-29 wurblzap@gmail.com -- Bug 257767 |
| csv_colsepchar => { options => [',',';'], default => ',' }, |
| # 2005-10-26 wurblzap@gmail.com -- Bug 291459 |
| zoom_textareas => { options => ["on", "off"], default => "on" }, |
| # 2006-05-01 olav@bkor.dhs.org -- Bug 7710 |
| state_addselfcc => { options => ['always', 'never', 'cc_unless_role'], |
| default => 'cc_unless_role' }, |
| # 2006-08-04 wurblzap@gmail.com -- Bug 322693 |
| skin => { subclass => 'Skin', default => 'Dusk' }, |
| # 2006-12-10 LpSolit@gmail.com -- Bug 297186 |
| lang => { subclass => 'Lang', |
| default => ${Bugzilla->languages}[0] }, |
| # 2007-07-02 altlist@gmail.com -- Bug 225731 |
| quote_replies => { options => ['quoted_reply', 'simple_reply', 'off'], |
| default => "quoted_reply" }, |
| # 2009-02-01 mozilla@matt.mchenryfamily.org -- Bug 398473 |
| comment_box_position => { options => ['before_comments', 'after_comments'], |
| default => 'before_comments' }, |
| # 2008-08-27 LpSolit@gmail.com -- Bug 182238 |
| timezone => { subclass => 'Timezone', default => 'local' }, |
| # 2011-02-07 dkl@mozilla.com -- Bug 580490 |
| quicksearch_fulltext => { options => ['on', 'off'], default => 'on' }, |
| # 2011-06-21 glob@mozilla.com -- Bug 589128 |
| email_format => { options => ['html', 'text_only'], |
| default => 'html' }, |
| # 2011-10-11 glob@mozilla.com -- Bug 301656 |
| requestee_cc => { options => ['on', 'off'], default => 'on' }, |
| # 2012-04-30 glob@mozilla.com -- Bug 663747 |
| bugmail_new_prefix => { options => ['on', 'off'], default => 'on' }, |
| # 2013-07-26 joshi_sunil@in.com -- Bug 669535 |
| possible_duplicates => { options => ['on', 'off'], default => 'on' }, |
| } |
| }; |
| |
| use constant SYSTEM_GROUPS => ( |
| { |
| name => 'admin', |
| description => 'Administrators' |
| }, |
| { |
| name => 'tweakparams', |
| description => 'Can change Parameters' |
| }, |
| { |
| name => 'editusers', |
| description => 'Can edit or disable users' |
| }, |
| { |
| name => 'creategroups', |
| description => 'Can create and destroy groups' |
| }, |
| { |
| name => 'editclassifications', |
| description => 'Can create, destroy, and edit classifications' |
| }, |
| { |
| name => 'editcomponents', |
| description => 'Can create, destroy, and edit components' |
| }, |
| { |
| name => 'editkeywords', |
| description => 'Can create, destroy, and edit keywords' |
| }, |
| { |
| name => 'editbugs', |
| description => 'Can edit all bug fields', |
| userregexp => '.*' |
| }, |
| { |
| name => 'canconfirm', |
| description => 'Can confirm a bug or mark it a duplicate' |
| }, |
| { |
| name => 'bz_canusewhineatothers', |
| description => 'Can configure whine reports for other users', |
| }, |
| { |
| name => 'bz_canusewhines', |
| description => 'User can configure whine reports for self', |
| # inherited_by means that users in the groups listed below are |
| # automatically members of bz_canusewhines. |
| inherited_by => ['editbugs', 'bz_canusewhineatothers'], |
| }, |
| { |
| name => 'bz_sudoers', |
| description => 'Can perform actions as other users', |
| }, |
| { |
| name => 'bz_sudo_protect', |
| description => 'Can not be impersonated by other users', |
| inherited_by => ['bz_sudoers'], |
| }, |
| { |
| name => 'bz_quip_moderators', |
| description => 'Can moderate quips', |
| }, |
| ); |
| |
| use constant DEFAULT_CLASSIFICATION => { |
| name => 'Unclassified', |
| description => 'Not assigned to any classification' |
| }; |
| |
| use constant DEFAULT_PRODUCT => { |
| name => 'TestProduct', |
| description => 'This is a test product.' |
| . ' This ought to be blown away and replaced with real stuff in a' |
| . ' finished installation of bugzilla.', |
| version => Bugzilla::Version::DEFAULT_VERSION, |
| classification => 'Unclassified', |
| defaultmilestone => DEFAULT_MILESTONE, |
| }; |
| |
| use constant DEFAULT_COMPONENT => { |
| name => 'TestComponent', |
| description => 'This is a test component in the test product database.' |
| . ' This ought to be blown away and replaced with real stuff in' |
| . ' a finished installation of Bugzilla.' |
| }; |
| |
| sub update_settings { |
| my $dbh = Bugzilla->dbh; |
| # If we're setting up settings for the first time, we want to be quieter. |
| my $any_settings = $dbh->selectrow_array( |
| 'SELECT 1 FROM setting ' . $dbh->sql_limit(1)); |
| if (!$any_settings) { |
| say get_text('install_setting_setup'); |
| } |
| |
| my %settings = %{SETTINGS()}; |
| foreach my $setting (keys %settings) { |
| add_setting($setting, |
| $settings{$setting}->{options}, |
| $settings{$setting}->{default}, |
| $settings{$setting}->{subclass}, undef, |
| !$any_settings); |
| } |
| |
| # Delete the obsolete 'per_bug_queries' user preference. Bug 616191. |
| $dbh->do('DELETE FROM setting WHERE name = ?', undef, 'per_bug_queries'); |
| } |
| |
| sub update_system_groups { |
| my $dbh = Bugzilla->dbh; |
| |
| $dbh->bz_start_transaction(); |
| |
| # If there is no editbugs group, this is the first time we're |
| # adding groups. |
| my $editbugs_exists = new Bugzilla::Group({ name => 'editbugs' }); |
| if (!$editbugs_exists) { |
| say get_text('install_groups_setup'); |
| } |
| |
| # Create most of the system groups |
| foreach my $definition (SYSTEM_GROUPS) { |
| my $exists = new Bugzilla::Group({ name => $definition->{name} }); |
| if (!$exists) { |
| $definition->{isbuggroup} = 0; |
| $definition->{silently} = !$editbugs_exists; |
| my $inherited_by = delete $definition->{inherited_by}; |
| my $created = Bugzilla::Group->create($definition); |
| # Each group in inherited_by is automatically a member of this |
| # group. |
| if ($inherited_by) { |
| foreach my $name (@$inherited_by) { |
| my $member = Bugzilla::Group->check($name); |
| $dbh->do('INSERT INTO group_group_map (grantor_id, |
| member_id) VALUES (?,?)', |
| undef, $created->id, $member->id); |
| } |
| } |
| } |
| } |
| |
| $dbh->bz_commit_transaction(); |
| } |
| |
| sub create_default_classification { |
| my $dbh = Bugzilla->dbh; |
| |
| # Make the default Classification if it doesn't already exist. |
| if (!$dbh->selectrow_array('SELECT 1 FROM classifications')) { |
| print get_text('install_default_classification', |
| { name => DEFAULT_CLASSIFICATION->{name} }) . "\n"; |
| Bugzilla::Classification->create(DEFAULT_CLASSIFICATION); |
| } |
| } |
| |
| # This function should be called only after creating the admin user. |
| sub create_default_product { |
| my $dbh = Bugzilla->dbh; |
| |
| # And same for the default product/component. |
| if (!$dbh->selectrow_array('SELECT 1 FROM products')) { |
| print get_text('install_default_product', |
| { name => DEFAULT_PRODUCT->{name} }) . "\n"; |
| |
| my $product = Bugzilla::Product->create(DEFAULT_PRODUCT); |
| |
| # Get the user who will be the owner of the Component. |
| # We pick the admin with the lowest id, which is probably the |
| # admin checksetup.pl just created. |
| my $admin_group = new Bugzilla::Group({name => 'admin'}); |
| my ($admin_id) = $dbh->selectrow_array( |
| 'SELECT user_id FROM user_group_map WHERE group_id = ? |
| ORDER BY user_id ' . $dbh->sql_limit(1), |
| undef, $admin_group->id); |
| my $admin = Bugzilla::User->new($admin_id); |
| |
| Bugzilla::Component->create({ |
| %{ DEFAULT_COMPONENT() }, product => $product, |
| initialowner => $admin->login }); |
| } |
| |
| } |
| |
| sub init_workflow { |
| my $dbh = Bugzilla->dbh; |
| my $has_workflow = $dbh->selectrow_array('SELECT 1 FROM status_workflow'); |
| return if $has_workflow; |
| |
| say get_text('install_workflow_init'); |
| |
| my %status_ids = @{ $dbh->selectcol_arrayref( |
| 'SELECT value, id FROM bug_status', {Columns=>[1,2]}) }; |
| |
| foreach my $pair (STATUS_WORKFLOW) { |
| my $old_id = $pair->[0] ? $status_ids{$pair->[0]} : undef; |
| my $new_id = $status_ids{$pair->[1]}; |
| $dbh->do('INSERT INTO status_workflow (old_status, new_status) |
| VALUES (?,?)', undef, $old_id, $new_id); |
| } |
| } |
| |
| sub create_admin { |
| my ($params) = @_; |
| my $dbh = Bugzilla->dbh; |
| my $template = Bugzilla->template; |
| |
| my $admin_group = new Bugzilla::Group({ name => 'admin' }); |
| my $admin_inheritors = |
| Bugzilla::Group->flatten_group_membership($admin_group->id); |
| my $admin_group_ids = join(',', @$admin_inheritors); |
| |
| my ($admin_count) = $dbh->selectrow_array( |
| "SELECT COUNT(*) FROM user_group_map |
| WHERE group_id IN ($admin_group_ids)"); |
| |
| return if $admin_count; |
| |
| my %answer = %{Bugzilla->installation_answers}; |
| my $login = $answer{'ADMIN_EMAIL'}; |
| my $password = $answer{'ADMIN_PASSWORD'}; |
| my $full_name = $answer{'ADMIN_REALNAME'}; |
| |
| if (!$login || !$password || !$full_name) { |
| say "\n" . get_text('install_admin_setup') . "\n"; |
| } |
| |
| while (!$login) { |
| print get_text('install_admin_get_email') . ' '; |
| $login = <STDIN>; |
| chomp $login; |
| eval { Bugzilla::User->check_login_name($login); }; |
| if ($@) { |
| say $@; |
| undef $login; |
| } |
| } |
| |
| while (!defined $full_name) { |
| print get_text('install_admin_get_name') . ' '; |
| $full_name = <STDIN>; |
| chomp($full_name); |
| } |
| |
| if (!$password) { |
| $password = _prompt_for_password( |
| get_text('install_admin_get_password')); |
| } |
| |
| my $admin = Bugzilla::User->create({ login_name => $login, |
| realname => $full_name, |
| cryptpassword => $password }); |
| make_admin($admin); |
| } |
| |
| sub make_admin { |
| my ($user) = @_; |
| my $dbh = Bugzilla->dbh; |
| |
| $user = ref($user) ? $user |
| : new Bugzilla::User(login_to_id($user, THROW_ERROR)); |
| |
| my $group_insert = $dbh->prepare( |
| 'INSERT INTO user_group_map (user_id, group_id, isbless, grant_type) |
| VALUES (?, ?, ?, ?)'); |
| |
| # Admins get explicit membership and bless capability for the admin group |
| my $admin_group = new Bugzilla::Group({ name => 'admin' }); |
| # These are run in an eval so that we can ignore the error of somebody |
| # already being granted these things. |
| eval { |
| $group_insert->execute($user->id, $admin_group->id, 0, GRANT_DIRECT); |
| }; |
| eval { |
| $group_insert->execute($user->id, $admin_group->id, 1, GRANT_DIRECT); |
| }; |
| |
| # Admins should also have editusers directly, even though they'll usually |
| # inherit it. People could have changed their inheritance structure. |
| my $editusers = new Bugzilla::Group({ name => 'editusers' }); |
| eval { |
| $group_insert->execute($user->id, $editusers->id, 0, GRANT_DIRECT); |
| }; |
| |
| # If there is no maintainer set, make this user the maintainer. |
| if (!Bugzilla->params->{'maintainer'}) { |
| SetParam('maintainer', $user->email); |
| write_params(); |
| } |
| |
| # Make sure the new admin isn't disabled |
| if ($user->disabledtext) { |
| $user->set_disabledtext(''); |
| $user->update(); |
| } |
| |
| if (Bugzilla->usage_mode == USAGE_MODE_CMDLINE) { |
| say "\n", get_text('install_admin_created', { user => $user }); |
| } |
| } |
| |
| sub _prompt_for_password { |
| my $prompt = shift; |
| |
| my $password; |
| while (!$password) { |
| # trap a few interrupts so we can fix the echo if we get aborted. |
| local $SIG{HUP} = \&_password_prompt_exit; |
| local $SIG{INT} = \&_password_prompt_exit; |
| local $SIG{QUIT} = \&_password_prompt_exit; |
| local $SIG{TERM} = \&_password_prompt_exit; |
| |
| system("stty","-echo") unless ON_WINDOWS; # disable input echoing |
| |
| print $prompt, ' '; |
| $password = <STDIN>; |
| chomp $password; |
| print "\n", get_text('install_confirm_password'), ' '; |
| my $pass2 = <STDIN>; |
| chomp $pass2; |
| eval { validate_password($password, $pass2); }; |
| if ($@) { |
| say "\n$@"; |
| undef $password; |
| } |
| system("stty","echo") unless ON_WINDOWS; |
| } |
| return $password; |
| } |
| |
| # This is just in case we get interrupted while getting a password. |
| sub _password_prompt_exit { |
| # re-enable input echoing |
| system("stty","echo") unless ON_WINDOWS; |
| exit 1; |
| } |
| |
| sub reset_password { |
| my $login = shift; |
| my $user = Bugzilla::User->check($login); |
| my $prompt = "\n" . get_text('install_reset_password', { user => $user }); |
| my $password = _prompt_for_password($prompt); |
| $user->set_password($password); |
| $user->update(); |
| say "\n", get_text('install_reset_password_done'); |
| } |
| |
| 1; |
| |
| __END__ |
| |
| =head1 NAME |
| |
| Bugzilla::Install - Functions and variables having to do with |
| installation. |
| |
| =head1 SYNOPSIS |
| |
| use Bugzilla::Install; |
| Bugzilla::Install::update_settings(); |
| |
| =head1 DESCRIPTION |
| |
| This module is used primarily by L<checksetup.pl> during installation. |
| This module contains functions that deal with general installation |
| issues after the database is completely set up and configured. |
| |
| =head1 CONSTANTS |
| |
| =over |
| |
| =item C<SETTINGS> |
| |
| Contains information about Settings, used by L</update_settings()>. |
| |
| =back |
| |
| =head1 SUBROUTINES |
| |
| =over |
| |
| =item C<update_settings()> |
| |
| Description: Adds and updates Settings for users. |
| |
| Params: none |
| |
| Returns: nothing. |
| |
| =item C<create_default_classification> |
| |
| Creates the default "Unclassified" L<Classification|Bugzilla::Classification> |
| if it doesn't already exist |
| |
| =item C<create_default_product()> |
| |
| Description: Creates the default product and component if |
| they don't exist. |
| |
| Params: none |
| |
| Returns: nothing |
| |
| =back |
| |
| =head1 B<Methods in need of POD> |
| |
| =over |
| |
| =item update_system_groups |
| |
| =item reset_password |
| |
| =item make_admin |
| |
| =item create_admin |
| |
| =item init_workflow |
| |
| =back |
