deac/gitolite
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity
gitolite/src/Gitolite/Rc.pm

291 lines
8.1 KiB
Perl
Raw Normal View History

(lotsa files affected) rc file format changed; see below The rc file used to be a bunch of variables, each one requiring to be declared before being used. While this was nice and all, it was a little cumbersome to add a new flag or option. If you disregard the "catch typos" aspect of having to predeclare variables, it's a lot more useful to have all of rc be in a hash and use any hash keys you want. There could be other uses; for instance it could hold arbitrary data that you would currently put in %ENV, without having to pollute %ENV if you don't need child tasks to inherit it. ---- NOTE: I also ran perltidy, which I don't always remember to :)
2012-03-16 05:29:45 +01:00
package Gitolite::Rc;
# everything to do with 'rc'. Also defines some 'constants'
# ----------------------------------------------------------------------
@EXPORT = qw(
%rc
glrc
query_rc
record and maintain a 'version' (for info and elsewhere)
2012-03-15 14:44:40 +01:00
version
(!!) trigger mechanism... read below new triggers: - PRE_GIT and POST_GIT in gitolite-shell - PRE_CREATE and POST_CREATE when a new wild repo is created - (POST_COMPILE had already existed) - ACCESS_CHECK triggers both in gitolite-shell and the update hook - trace() learned to print the file name if called from top level and a function name is not available note: trigger was called 'run-all' and only had POST_COMPILE. The code existed in gitolite-shell, but is now moved to Rc.pm.
2012-03-19 03:01:09 +01:00
trigger
(lotsa files affected) rc file format changed; see below The rc file used to be a bunch of variables, each one requiring to be declared before being used. While this was nice and all, it was a little cumbersome to add a new flag or option. If you disregard the "catch typos" aspect of having to predeclare variables, it's a lot more useful to have all of rc be in a hash and use any hash keys you want. There could be other uses; for instance it could hold arbitrary data that you would currently put in %ENV, without having to pollute %ENV if you don't need child tasks to inherit it. ---- NOTE: I also ran perltidy, which I don't always remember to :)
2012-03-16 05:29:45 +01:00
'info' command, plus lots more changes: - usage() gets a little smarter; it now knows what function it was called from and tries to find a '=for function_name' chunk of data in the script - the various list-* functions now work off a dispatcher in Load.pm - (...and they all use the new usage() magic to print their helps!) - src/gitolite got a lot leaner due to this dispatcher - src/gitolite-shell became a lot more easier to read/flow - rc acquired '{COMMANDS}', which gitolite-shell now refers to - comments in the default rc file changed a bit - rc got a new REMOTE_COMMAND_PATT (in place of ADC_CMD_ARGS_PATT) the rest is perltidy and stuff like that
2012-03-12 16:24:30 +01:00
$REMOTE_COMMAND_PATT
(lotsa files affected) rc file format changed; see below The rc file used to be a bunch of variables, each one requiring to be declared before being used. While this was nice and all, it was a little cumbersome to add a new flag or option. If you disregard the "catch typos" aspect of having to predeclare variables, it's a lot more useful to have all of rc be in a hash and use any hash keys you want. There could be other uses; for instance it could hold arbitrary data that you would currently put in %ENV, without having to pollute %ENV if you don't need child tasks to inherit it. ---- NOTE: I also ran perltidy, which I don't always remember to :)
2012-03-16 05:29:45 +01:00
$REF_OR_FILENAME_PATT
$REPONAME_PATT
$REPOPATT_PATT
$USERNAME_PATT
git_configs almost done, but real testing can only happen after wildrepos is finished (specifically, when memberships() can return regex repo names also)
2012-03-16 09:59:45 +01:00
$UNSAFE_PATT
(lotsa files affected) rc file format changed; see below The rc file used to be a bunch of variables, each one requiring to be declared before being used. While this was nice and all, it was a little cumbersome to add a new flag or option. If you disregard the "catch typos" aspect of having to predeclare variables, it's a lot more useful to have all of rc be in a hash and use any hash keys you want. There could be other uses; for instance it could hold arbitrary data that you would currently put in %ENV, without having to pollute %ENV if you don't need child tasks to inherit it. ---- NOTE: I also ran perltidy, which I don't always remember to :)
2012-03-16 05:29:45 +01:00
);
use Exporter 'import';
use Getopt::Long;
use Gitolite::Common;
# ----------------------------------------------------------------------
our %rc;
# ----------------------------------------------------------------------
logging (but see below) The logging is both for paranoia and parsing/automated processing. The ones you're probably interested in parsing should be easy to pick out and are very likely to have tab-delimited fields already.
2012-03-17 16:43:28 +01:00
# variables that could be overridden by the rc file
(lotsa files affected) rc file format changed; see below The rc file used to be a bunch of variables, each one requiring to be declared before being used. While this was nice and all, it was a little cumbersome to add a new flag or option. If you disregard the "catch typos" aspect of having to predeclare variables, it's a lot more useful to have all of rc be in a hash and use any hash keys you want. There could be other uses; for instance it could hold arbitrary data that you would currently put in %ENV, without having to pollute %ENV if you don't need child tasks to inherit it. ---- NOTE: I also ran perltidy, which I don't always remember to :)
2012-03-16 05:29:45 +01:00
# ----------------------------------------------------------------------
logging (but see below) The logging is both for paranoia and parsing/automated processing. The ones you're probably interested in parsing should be easy to pick out and are very likely to have tab-delimited fields already.
2012-03-17 16:43:28 +01:00
$rc{GL_BINDIR} = $ENV{GL_BINDIR};
$rc{GL_REPO_BASE} = "$ENV{HOME}/repositories";
(lotsa files affected) rc file format changed; see below The rc file used to be a bunch of variables, each one requiring to be declared before being used. While this was nice and all, it was a little cumbersome to add a new flag or option. If you disregard the "catch typos" aspect of having to predeclare variables, it's a lot more useful to have all of rc be in a hash and use any hash keys you want. There could be other uses; for instance it could hold arbitrary data that you would currently put in %ENV, without having to pollute %ENV if you don't need child tasks to inherit it. ---- NOTE: I also ran perltidy, which I don't always remember to :)
2012-03-16 05:29:45 +01:00
$rc{GL_ADMIN_BASE} = "$ENV{HOME}/.gitolite";
logging (but see below) The logging is both for paranoia and parsing/automated processing. The ones you're probably interested in parsing should be easy to pick out and are very likely to have tab-delimited fields already.
2012-03-17 16:43:28 +01:00
$rc{LOG_TEMPLATE} = "$ENV{HOME}/.gitolite/logs/gitolite-%y-%m.log";
(lotsa files affected) rc file format changed; see below The rc file used to be a bunch of variables, each one requiring to be declared before being used. While this was nice and all, it was a little cumbersome to add a new flag or option. If you disregard the "catch typos" aspect of having to predeclare variables, it's a lot more useful to have all of rc be in a hash and use any hash keys you want. There could be other uses; for instance it could hold arbitrary data that you would currently put in %ENV, without having to pollute %ENV if you don't need child tasks to inherit it. ---- NOTE: I also ran perltidy, which I don't always remember to :)
2012-03-16 05:29:45 +01:00
logging (but see below) The logging is both for paranoia and parsing/automated processing. The ones you're probably interested in parsing should be easy to pick out and are very likely to have tab-delimited fields already.
2012-03-17 16:43:28 +01:00
# variables that should probably never be changed but someone will want to, I'll bet...
(lotsa files affected) rc file format changed; see below The rc file used to be a bunch of variables, each one requiring to be declared before being used. While this was nice and all, it was a little cumbersome to add a new flag or option. If you disregard the "catch typos" aspect of having to predeclare variables, it's a lot more useful to have all of rc be in a hash and use any hash keys you want. There could be other uses; for instance it could hold arbitrary data that you would currently put in %ENV, without having to pollute %ENV if you don't need child tasks to inherit it. ---- NOTE: I also ran perltidy, which I don't always remember to :)
2012-03-16 05:29:45 +01:00
# ----------------------------------------------------------------------
'info' command, plus lots more changes: - usage() gets a little smarter; it now knows what function it was called from and tries to find a '=for function_name' chunk of data in the script - the various list-* functions now work off a dispatcher in Load.pm - (...and they all use the new usage() magic to print their helps!) - src/gitolite got a lot leaner due to this dispatcher - src/gitolite-shell became a lot more easier to read/flow - rc acquired '{COMMANDS}', which gitolite-shell now refers to - comments in the default rc file changed a bit - rc got a new REMOTE_COMMAND_PATT (in place of ADC_CMD_ARGS_PATT) the rest is perltidy and stuff like that
2012-03-12 16:24:30 +01:00
$REMOTE_COMMAND_PATT = qr(^[- 0-9a-zA-Z\@\%_=+:,./]*$);
(lotsa files affected) rc file format changed; see below The rc file used to be a bunch of variables, each one requiring to be declared before being used. While this was nice and all, it was a little cumbersome to add a new flag or option. If you disregard the "catch typos" aspect of having to predeclare variables, it's a lot more useful to have all of rc be in a hash and use any hash keys you want. There could be other uses; for instance it could hold arbitrary data that you would currently put in %ENV, without having to pollute %ENV if you don't need child tasks to inherit it. ---- NOTE: I also ran perltidy, which I don't always remember to :)
2012-03-16 05:29:45 +01:00
$REF_OR_FILENAME_PATT = qr(^[0-9a-zA-Z][0-9a-zA-Z._\@/+ :,-]*$);
$REPONAME_PATT = qr(^\@?[0-9a-zA-Z][0-9a-zA-Z._\@/+-]*$);
$REPOPATT_PATT = qr(^\@?[0-9a-zA-Z[][\\^.$|()[\]*+?{}0-9a-zA-Z._\@/,-]*$);
$USERNAME_PATT = qr(^\@?[0-9a-zA-Z][0-9a-zA-Z._\@+-]*$);
git_configs almost done, but real testing can only happen after wildrepos is finished (specifically, when memberships() can return regex repo names also)
2012-03-16 09:59:45 +01:00
$UNSAFE_PATT = qr([`~#\$\&()|;<>]);
(lotsa files affected) rc file format changed; see below The rc file used to be a bunch of variables, each one requiring to be declared before being used. While this was nice and all, it was a little cumbersome to add a new flag or option. If you disregard the "catch typos" aspect of having to predeclare variables, it's a lot more useful to have all of rc be in a hash and use any hash keys you want. There could be other uses; for instance it could hold arbitrary data that you would currently put in %ENV, without having to pollute %ENV if you don't need child tasks to inherit it. ---- NOTE: I also ran perltidy, which I don't always remember to :)
2012-03-16 05:29:45 +01:00
# ----------------------------------------------------------------------
logging (but see below) The logging is both for paranoia and parsing/automated processing. The ones you're probably interested in parsing should be easy to pick out and are very likely to have tab-delimited fields already.
2012-03-17 16:43:28 +01:00
# find the rc file and 'do' it
# ----------------------------------------------------------------------
(lotsa files affected) rc file format changed; see below The rc file used to be a bunch of variables, each one requiring to be declared before being used. While this was nice and all, it was a little cumbersome to add a new flag or option. If you disregard the "catch typos" aspect of having to predeclare variables, it's a lot more useful to have all of rc be in a hash and use any hash keys you want. There could be other uses; for instance it could hold arbitrary data that you would currently put in %ENV, without having to pollute %ENV if you don't need child tasks to inherit it. ---- NOTE: I also ran perltidy, which I don't always remember to :)
2012-03-16 05:29:45 +01:00
my $current_data_version = "3.0";
my $rc = glrc('filename');
do $rc if -r $rc;
run compat checks when old rc found (also removed legacy-delegation sugar script)
2012-03-22 01:47:34 +01:00
if (defined($GL_ADMINDIR)) {
say2 "";
say2 "FATAL: $rc seems to be for older gitolite; checking compat";
require Gitolite::Compat;
exit 1;
}
(lotsa files affected) rc file format changed; see below The rc file used to be a bunch of variables, each one requiring to be declared before being used. While this was nice and all, it was a little cumbersome to add a new flag or option. If you disregard the "catch typos" aspect of having to predeclare variables, it's a lot more useful to have all of rc be in a hash and use any hash keys you want. There could be other uses; for instance it could hold arbitrary data that you would currently put in %ENV, without having to pollute %ENV if you don't need child tasks to inherit it. ---- NOTE: I also ran perltidy, which I don't always remember to :)
2012-03-16 05:29:45 +01:00
# let values specified in rc file override our internal ones
@rc{ keys %RC } = values %RC;
logging (but see below) The logging is both for paranoia and parsing/automated processing. The ones you're probably interested in parsing should be easy to pick out and are very likely to have tab-delimited fields already.
2012-03-17 16:43:28 +01:00
# (testing only) testing sometimes requires all of it to be overridden
# silently; use an env var that is highly unlikely to appear in real life :)
(perltidy)
2012-03-15 15:34:30 +01:00
do $ENV{G3T_RC} if exists $ENV{G3T_RC} and -r $ENV{G3T_RC};
(testing help) allow a *testing* rc to override the normal one
2012-03-15 10:35:51 +01:00
logging (but see below) The logging is both for paranoia and parsing/automated processing. The ones you're probably interested in parsing should be easy to pick out and are very likely to have tab-delimited fields already.
2012-03-17 16:43:28 +01:00
# fix some env vars, setup gitolite internal "env" vars (aka rc vars)
# ----------------------------------------------------------------------
(rc) prefix GL_BINDIR to PATH Needed when the user didn't actually "install" but is just running it by using the full path to "gitolite". Without this, every time my code runs "gitolite <some sub-command>" I have to prefix "gitolite" with $ENV{GL_BINDIR}, which is kinda painful...
2012-03-12 04:08:50 +01:00
$ENV{PATH} = "$ENV{GL_BINDIR}:$ENV{PATH}";
logging (but see below) The logging is both for paranoia and parsing/automated processing. The ones you're probably interested in parsing should be easy to pick out and are very likely to have tab-delimited fields already.
2012-03-17 16:43:28 +01:00
{
cleaned up logging quite a bit; details: - a remote "id" (usually the IP) is generated and logged on the first log message in a "transaction" - speaking of which, a new "transaction ID" is logged that stays the same for each input command/invocation, tying together all the spawned commands - so now time stamps can be generated each time they are needed, rather than re-use the one at the beginning - log messages have a keyword at the start now remote, (create), check1 -- from gitolite-shell update, check2 -- from update post-up -- from post-update command -- from gitolite die, system -- from anywhere
2012-03-21 11:53:50 +01:00
$rc{GL_TID} = $ENV{GL_TID} ||= $$;
# TID: loosely, transaction ID. The first PID at the entry point passes
# it down to all its children so you can track each access, across all the
# various commands it spawns and actions it generates.
$rc{GL_LOGFILE} = $ENV{GL_LOGFILE} ||= gen_lfn( $rc{LOG_TEMPLATE} );
logging (but see below) The logging is both for paranoia and parsing/automated processing. The ones you're probably interested in parsing should be easy to pick out and are very likely to have tab-delimited fields already.
2012-03-17 16:43:28 +01:00
}
make site-local scripts easier to write - new Gitolite::Easy module hides all the other stuff - (put GL_ADMIN_BASE and GL_REPO_BASE into %ENV) - new 'gitolite creator' shell command - 'writes' command modified to use Gitolite::Easy. It is also the only dual mode command -- it can be invoked remotely as well as locally. I deem that the required trick to make other remote-only commands work locally is too much trouble for what is probably a rarely used command.
2012-03-20 18:30:29 +01:00
# these two are meant to help externally written commands (see
# src/commands/writes for an example)
$ENV{GL_REPO_BASE} = $rc{GL_REPO_BASE};
$ENV{GL_ADMIN_BASE} = $rc{GL_ADMIN_BASE};
(lotsa files affected) rc file format changed; see below The rc file used to be a bunch of variables, each one requiring to be declared before being used. While this was nice and all, it was a little cumbersome to add a new flag or option. If you disregard the "catch typos" aspect of having to predeclare variables, it's a lot more useful to have all of rc be in a hash and use any hash keys you want. There could be other uses; for instance it could hold arbitrary data that you would currently put in %ENV, without having to pollute %ENV if you don't need child tasks to inherit it. ---- NOTE: I also ran perltidy, which I don't always remember to :)
2012-03-16 05:29:45 +01:00
# ----------------------------------------------------------------------
use strict;
use warnings;
# ----------------------------------------------------------------------
my $glrc_default_text = '';
{
local $/ = undef;
$glrc_default_text = <DATA>;
}
sub glrc {
my $cmd = shift;
if ( $cmd eq 'default-filename' ) {
return "$ENV{HOME}/.gitolite.rc";
} elsif ( $cmd eq 'default-text' ) {
return $glrc_default_text if $glrc_default_text;
_die "rc file default text not set; this should not happen!";
} elsif ( $cmd eq 'filename' ) {
# where is the rc file?
# search $HOME first
return "$ENV{HOME}/.gitolite.rc" if -f "$ENV{HOME}/.gitolite.rc";
return '';
} elsif ( $cmd eq 'current-data-version' ) {
return $current_data_version;
} else {
_die "unknown argument to glrc: $cmd";
}
}
(!!) trigger mechanism... read below new triggers: - PRE_GIT and POST_GIT in gitolite-shell - PRE_CREATE and POST_CREATE when a new wild repo is created - (POST_COMPILE had already existed) - ACCESS_CHECK triggers both in gitolite-shell and the update hook - trace() learned to print the file name if called from top level and a function name is not available note: trigger was called 'run-all' and only had POST_COMPILE. The code existed in gitolite-shell, but is now moved to Rc.pm.
2012-03-19 03:01:09 +01:00
# exported functions
(lotsa files affected) rc file format changed; see below The rc file used to be a bunch of variables, each one requiring to be declared before being used. While this was nice and all, it was a little cumbersome to add a new flag or option. If you disregard the "catch typos" aspect of having to predeclare variables, it's a lot more useful to have all of rc be in a hash and use any hash keys you want. There could be other uses; for instance it could hold arbitrary data that you would currently put in %ENV, without having to pollute %ENV if you don't need child tasks to inherit it. ---- NOTE: I also ran perltidy, which I don't always remember to :)
2012-03-16 05:29:45 +01:00
# ----------------------------------------------------------------------
'info' command, plus lots more changes: - usage() gets a little smarter; it now knows what function it was called from and tries to find a '=for function_name' chunk of data in the script - the various list-* functions now work off a dispatcher in Load.pm - (...and they all use the new usage() magic to print their helps!) - src/gitolite got a lot leaner due to this dispatcher - src/gitolite-shell became a lot more easier to read/flow - rc acquired '{COMMANDS}', which gitolite-shell now refers to - comments in the default rc file changed a bit - rc got a new REMOTE_COMMAND_PATT (in place of ADC_CMD_ARGS_PATT) the rest is perltidy and stuff like that
2012-03-12 16:24:30 +01:00
my $all = 0;
query-rc learned '-n' to avoid the need to chomp() the result
2012-03-11 17:15:07 +01:00
my $nonl = 0;
(lotsa files affected) rc file format changed; see below The rc file used to be a bunch of variables, each one requiring to be declared before being used. While this was nice and all, it was a little cumbersome to add a new flag or option. If you disregard the "catch typos" aspect of having to predeclare variables, it's a lot more useful to have all of rc be in a hash and use any hash keys you want. There could be other uses; for instance it could hold arbitrary data that you would currently put in %ENV, without having to pollute %ENV if you don't need child tasks to inherit it. ---- NOTE: I also ran perltidy, which I don't always remember to :)
2012-03-16 05:29:45 +01:00
sub query_rc {
my @vars = args();
no strict 'refs';
'info' command, plus lots more changes: - usage() gets a little smarter; it now knows what function it was called from and tries to find a '=for function_name' chunk of data in the script - the various list-* functions now work off a dispatcher in Load.pm - (...and they all use the new usage() magic to print their helps!) - src/gitolite got a lot leaner due to this dispatcher - src/gitolite-shell became a lot more easier to read/flow - rc acquired '{COMMANDS}', which gitolite-shell now refers to - comments in the default rc file changed a bit - rc got a new REMOTE_COMMAND_PATT (in place of ADC_CMD_ARGS_PATT) the rest is perltidy and stuff like that
2012-03-12 16:24:30 +01:00
if ($all) {
for my $e ( sort keys %rc ) {
print "$e=" . ( defined( $rc{$e} ) ? $rc{$e} : 'undef' ) . "\n";
(lotsa files affected) rc file format changed; see below The rc file used to be a bunch of variables, each one requiring to be declared before being used. While this was nice and all, it was a little cumbersome to add a new flag or option. If you disregard the "catch typos" aspect of having to predeclare variables, it's a lot more useful to have all of rc be in a hash and use any hash keys you want. There could be other uses; for instance it could hold arbitrary data that you would currently put in %ENV, without having to pollute %ENV if you don't need child tasks to inherit it. ---- NOTE: I also ran perltidy, which I don't always remember to :)
2012-03-16 05:29:45 +01:00
}
'info' command, plus lots more changes: - usage() gets a little smarter; it now knows what function it was called from and tries to find a '=for function_name' chunk of data in the script - the various list-* functions now work off a dispatcher in Load.pm - (...and they all use the new usage() magic to print their helps!) - src/gitolite got a lot leaner due to this dispatcher - src/gitolite-shell became a lot more easier to read/flow - rc acquired '{COMMANDS}', which gitolite-shell now refers to - comments in the default rc file changed a bit - rc got a new REMOTE_COMMAND_PATT (in place of ADC_CMD_ARGS_PATT) the rest is perltidy and stuff like that
2012-03-12 16:24:30 +01:00
exit 0;
(lotsa files affected) rc file format changed; see below The rc file used to be a bunch of variables, each one requiring to be declared before being used. While this was nice and all, it was a little cumbersome to add a new flag or option. If you disregard the "catch typos" aspect of having to predeclare variables, it's a lot more useful to have all of rc be in a hash and use any hash keys you want. There could be other uses; for instance it could hold arbitrary data that you would currently put in %ENV, without having to pollute %ENV if you don't need child tasks to inherit it. ---- NOTE: I also ran perltidy, which I don't always remember to :)
2012-03-16 05:29:45 +01:00
}
'info' command, plus lots more changes: - usage() gets a little smarter; it now knows what function it was called from and tries to find a '=for function_name' chunk of data in the script - the various list-* functions now work off a dispatcher in Load.pm - (...and they all use the new usage() magic to print their helps!) - src/gitolite got a lot leaner due to this dispatcher - src/gitolite-shell became a lot more easier to read/flow - rc acquired '{COMMANDS}', which gitolite-shell now refers to - comments in the default rc file changed a bit - rc got a new REMOTE_COMMAND_PATT (in place of ADC_CMD_ARGS_PATT) the rest is perltidy and stuff like that
2012-03-12 16:24:30 +01:00
my @res = map { $rc{$_} } grep { $rc{$_} } @vars;
print join( "\t", @res ) . ( $nonl ? '' : "\n" ) if @res;
# shell truth
exit 0 if @res;
exit 1;
(lotsa files affected) rc file format changed; see below The rc file used to be a bunch of variables, each one requiring to be declared before being used. While this was nice and all, it was a little cumbersome to add a new flag or option. If you disregard the "catch typos" aspect of having to predeclare variables, it's a lot more useful to have all of rc be in a hash and use any hash keys you want. There could be other uses; for instance it could hold arbitrary data that you would currently put in %ENV, without having to pollute %ENV if you don't need child tasks to inherit it. ---- NOTE: I also ran perltidy, which I don't always remember to :)
2012-03-16 05:29:45 +01:00
}
record and maintain a 'version' (for info and elsewhere)
2012-03-15 14:44:40 +01:00
sub version {
my $version = '';
$version = '(unknown)';
for ("$rc{GL_ADMIN_BASE}/VERSION") {
$version = slurp($_) if -r $_;
}
chomp($version);
return $version;
}
(!!) trigger mechanism... read below new triggers: - PRE_GIT and POST_GIT in gitolite-shell - PRE_CREATE and POST_CREATE when a new wild repo is created - (POST_COMPILE had already existed) - ACCESS_CHECK triggers both in gitolite-shell and the update hook - trace() learned to print the file name if called from top level and a function name is not available note: trigger was called 'run-all' and only had POST_COMPILE. The code existed in gitolite-shell, but is now moved to Rc.pm.
2012-03-19 03:01:09 +01:00
sub trigger {
my $rc_section = shift;
if ( exists $rc{$rc_section} ) {
if ( ref( $rc{$rc_section} ) ne 'ARRAY' ) {
_die "$rc_section section in rc file is not a perl list";
} else {
for my $s ( @{ $rc{$rc_section} } ) {
# perl-ism; apart from keeping the full path separate from the
# simple name, this also protects %rc from change by implicit
# aliasing, which would happen if you touched $s itself
my $sfp = "$ENV{GL_BINDIR}/commands/$s";
_warn("skipped command '$s'"), next if not -x $sfp;
trace( 2, "command: $s" );
_system( $sfp, @_ ); # they better all return with 0 exit codes!
}
}
return;
}
trace( 2, "'$rc_section' not found in rc" );
}
(lotsa files affected) rc file format changed; see below The rc file used to be a bunch of variables, each one requiring to be declared before being used. While this was nice and all, it was a little cumbersome to add a new flag or option. If you disregard the "catch typos" aspect of having to predeclare variables, it's a lot more useful to have all of rc be in a hash and use any hash keys you want. There could be other uses; for instance it could hold arbitrary data that you would currently put in %ENV, without having to pollute %ENV if you don't need child tasks to inherit it. ---- NOTE: I also ran perltidy, which I don't always remember to :)
2012-03-16 05:29:45 +01:00
# ----------------------------------------------------------------------
'info' command, plus lots more changes: - usage() gets a little smarter; it now knows what function it was called from and tries to find a '=for function_name' chunk of data in the script - the various list-* functions now work off a dispatcher in Load.pm - (...and they all use the new usage() magic to print their helps!) - src/gitolite got a lot leaner due to this dispatcher - src/gitolite-shell became a lot more easier to read/flow - rc acquired '{COMMANDS}', which gitolite-shell now refers to - comments in the default rc file changed a bit - rc got a new REMOTE_COMMAND_PATT (in place of ADC_CMD_ARGS_PATT) the rest is perltidy and stuff like that
2012-03-12 16:24:30 +01:00
=for args
Usage: gitolite query-rc -a
gitolite query-rc [-n] <list of rc variables>
-a print all variables and values
-n do not append a newline
Example:
gitolite query-rc GL_ADMIN_BASE UMASK
# prints "/home/git/.gitolite<tab>0077" or similar
gitolite query-rc -a
# prints all known variables and values, one per line
=cut
(lotsa files affected) rc file format changed; see below The rc file used to be a bunch of variables, each one requiring to be declared before being used. While this was nice and all, it was a little cumbersome to add a new flag or option. If you disregard the "catch typos" aspect of having to predeclare variables, it's a lot more useful to have all of rc be in a hash and use any hash keys you want. There could be other uses; for instance it could hold arbitrary data that you would currently put in %ENV, without having to pollute %ENV if you don't need child tasks to inherit it. ---- NOTE: I also ran perltidy, which I don't always remember to :)
2012-03-16 05:29:45 +01:00
sub args {
my $help = 0;
GetOptions(
'all|a' => \$all,
query-rc learned '-n' to avoid the need to chomp() the result
2012-03-11 17:15:07 +01:00
'nonl|n' => \$nonl,
(lotsa files affected) rc file format changed; see below The rc file used to be a bunch of variables, each one requiring to be declared before being used. While this was nice and all, it was a little cumbersome to add a new flag or option. If you disregard the "catch typos" aspect of having to predeclare variables, it's a lot more useful to have all of rc be in a hash and use any hash keys you want. There could be other uses; for instance it could hold arbitrary data that you would currently put in %ENV, without having to pollute %ENV if you don't need child tasks to inherit it. ---- NOTE: I also ran perltidy, which I don't always remember to :)
2012-03-16 05:29:45 +01:00
'help|h' => \$help,
) or usage();
usage("'-a' cannot be combined with other arguments") if $all and @ARGV;
usage() if not $all and not @ARGV or $help;
return @ARGV;
}
1;
# ----------------------------------------------------------------------
__DATA__
# configuration variables for gitolite
'info' command, plus lots more changes: - usage() gets a little smarter; it now knows what function it was called from and tries to find a '=for function_name' chunk of data in the script - the various list-* functions now work off a dispatcher in Load.pm - (...and they all use the new usage() magic to print their helps!) - src/gitolite got a lot leaner due to this dispatcher - src/gitolite-shell became a lot more easier to read/flow - rc acquired '{COMMANDS}', which gitolite-shell now refers to - comments in the default rc file changed a bit - rc got a new REMOTE_COMMAND_PATT (in place of ADC_CMD_ARGS_PATT) the rest is perltidy and stuff like that
2012-03-12 16:24:30 +01:00
# This file is in perl syntax. But you do NOT need to know perl to edit it --
gl-perms handling and roles, first cut (additional memberships that user has when accessing a specific repo)
2012-03-17 07:55:38 +01:00
# just mind the commas, use single quotes unless you know what you're doing,
# and make sure the brackets and braces stay matched up!
ssh-authkeys done!
2012-03-11 17:03:15 +01:00
'info' command, plus lots more changes: - usage() gets a little smarter; it now knows what function it was called from and tries to find a '=for function_name' chunk of data in the script - the various list-* functions now work off a dispatcher in Load.pm - (...and they all use the new usage() magic to print their helps!) - src/gitolite got a lot leaner due to this dispatcher - src/gitolite-shell became a lot more easier to read/flow - rc acquired '{COMMANDS}', which gitolite-shell now refers to - comments in the default rc file changed a bit - rc got a new REMOTE_COMMAND_PATT (in place of ADC_CMD_ARGS_PATT) the rest is perltidy and stuff like that
2012-03-12 16:24:30 +01:00
# (Tip: perl allows a comma after the last item in a list also!)
(lotsa files affected) rc file format changed; see below The rc file used to be a bunch of variables, each one requiring to be declared before being used. While this was nice and all, it was a little cumbersome to add a new flag or option. If you disregard the "catch typos" aspect of having to predeclare variables, it's a lot more useful to have all of rc be in a hash and use any hash keys you want. There could be other uses; for instance it could hold arbitrary data that you would currently put in %ENV, without having to pollute %ENV if you don't need child tasks to inherit it. ---- NOTE: I also ran perltidy, which I don't always remember to :)
2012-03-16 05:29:45 +01:00
%RC = (
UMASK => 0077,
gl-perms handling and roles, first cut (additional memberships that user has when accessing a specific repo)
2012-03-17 07:55:38 +01:00
GIT_CONFIG_KEYS => '',
# add more roles (like MANAGER, TESTER, ...) here
ROLES =>
{
READERS => 1,
WRITERS => 1,
},
# uncomment (and change) this if you wish
# DEFAULT_ROLE_PERMS => 'READERS @all',
example sugar script 'continuation-lines' added
2012-03-10 15:13:42 +01:00
ssh-authkeys done!
2012-03-11 17:03:15 +01:00
# comment out or uncomment as needed
'info' command, plus lots more changes: - usage() gets a little smarter; it now knows what function it was called from and tries to find a '=for function_name' chunk of data in the script - the various list-* functions now work off a dispatcher in Load.pm - (...and they all use the new usage() magic to print their helps!) - src/gitolite got a lot leaner due to this dispatcher - src/gitolite-shell became a lot more easier to read/flow - rc acquired '{COMMANDS}', which gitolite-shell now refers to - comments in the default rc file changed a bit - rc got a new REMOTE_COMMAND_PATT (in place of ADC_CMD_ARGS_PATT) the rest is perltidy and stuff like that
2012-03-12 16:24:30 +01:00
# these will run in sequence during the conf file parse
example sugar script 'continuation-lines' added
2012-03-10 15:13:42 +01:00
SYNTACTIC_SUGAR =>
[
# 'continuation-lines',
ssh-authkeys done!
2012-03-11 17:03:15 +01:00
],
# comment out or uncomment as needed
'info' command, plus lots more changes: - usage() gets a little smarter; it now knows what function it was called from and tries to find a '=for function_name' chunk of data in the script - the various list-* functions now work off a dispatcher in Load.pm - (...and they all use the new usage() magic to print their helps!) - src/gitolite got a lot leaner due to this dispatcher - src/gitolite-shell became a lot more easier to read/flow - rc acquired '{COMMANDS}', which gitolite-shell now refers to - comments in the default rc file changed a bit - rc got a new REMOTE_COMMAND_PATT (in place of ADC_CMD_ARGS_PATT) the rest is perltidy and stuff like that
2012-03-12 16:24:30 +01:00
# these will run in sequence after post-update
ssh-authkeys done!
2012-03-11 17:03:15 +01:00
POST_COMPILE =>
[
changes to custom command invocation etc.; see below - 'post-compile' subdir moved under 'commands/' but only for sanity; has no real significance now - new, internal use only, gitolite command run-all, as in gitolite run-all POST_COMPILE which runs all the commands in @{ $rc{POST_COMPILE} } in sequence. You can sdo this for any section of course, though this is the only one in the rc right now. (Future candidates: PRE_GIT, POST_GIT, PRE_CREATE, POST_CREATE)
2012-03-16 04:55:39 +01:00
'post-compile/ssh-authkeys',
git-configs update code done
2012-03-19 11:45:21 +01:00
'post-compile/update-git-configs',
gitweb/daemon post-create scripts done
2012-03-19 09:34:17 +01:00
'post-compile/update-gitweb-access-list',
'post-compile/update-git-daemon-access-list',
],
# comment out or uncomment as needed
# these will run in sequence after a new wild repo is created
POST_CREATE =>
[
trigger POST_CREATE from user actions - uncomment the POST_CREATE section in rc by default now - have perms call 'gitolite trigger POST_CREATE'
2012-03-21 08:53:32 +01:00
'post-compile/update-git-configs',
'post-compile/update-gitweb-access-list',
'post-compile/update-git-daemon-access-list',
ssh-authkeys done!
2012-03-11 17:03:15 +01:00
],
'info' command, plus lots more changes: - usage() gets a little smarter; it now knows what function it was called from and tries to find a '=for function_name' chunk of data in the script - the various list-* functions now work off a dispatcher in Load.pm - (...and they all use the new usage() magic to print their helps!) - src/gitolite got a lot leaner due to this dispatcher - src/gitolite-shell became a lot more easier to read/flow - rc acquired '{COMMANDS}', which gitolite-shell now refers to - comments in the default rc file changed a bit - rc got a new REMOTE_COMMAND_PATT (in place of ADC_CMD_ARGS_PATT) the rest is perltidy and stuff like that
2012-03-12 16:24:30 +01:00
# comment out or uncomment as needed
# these are available to remote users
COMMANDS =>
{
changes to custom command invocation etc.; see below - 'post-compile' subdir moved under 'commands/' but only for sanity; has no real significance now - new, internal use only, gitolite command run-all, as in gitolite run-all POST_COMPILE which runs all the commands in @{ $rc{POST_COMPILE} } in sequence. You can sdo this for any section of course, though this is the only one in the rc right now. (Future candidates: PRE_GIT, POST_GIT, PRE_CREATE, POST_CREATE)
2012-03-16 04:55:39 +01:00
'help' => 1,
'info' command, plus lots more changes: - usage() gets a little smarter; it now knows what function it was called from and tries to find a '=for function_name' chunk of data in the script - the various list-* functions now work off a dispatcher in Load.pm - (...and they all use the new usage() magic to print their helps!) - src/gitolite got a lot leaner due to this dispatcher - src/gitolite-shell became a lot more easier to read/flow - rc acquired '{COMMANDS}', which gitolite-shell now refers to - comments in the default rc file changed a bit - rc got a new REMOTE_COMMAND_PATT (in place of ADC_CMD_ARGS_PATT) the rest is perltidy and stuff like that
2012-03-12 16:24:30 +01:00
'info' => 1,
'desc' command added (manually smoke tested only; no test script)
2012-03-21 03:19:13 +01:00
'desc' => 1,
perms command done (smoke tested)
2012-03-18 05:20:24 +01:00
'perms' => 1,
make site-local scripts easier to write - new Gitolite::Easy module hides all the other stuff - (put GL_ADMIN_BASE and GL_REPO_BASE into %ENV) - new 'gitolite creator' shell command - 'writes' command modified to use Gitolite::Easy. It is also the only dual mode command -- it can be invoked remotely as well as locally. I deem that the required trick to make other remote-only commands work locally is too much trouble for what is probably a rarely used command.
2012-03-20 18:30:29 +01:00
'writes' => 1,
'info' command, plus lots more changes: - usage() gets a little smarter; it now knows what function it was called from and tries to find a '=for function_name' chunk of data in the script - the various list-* functions now work off a dispatcher in Load.pm - (...and they all use the new usage() magic to print their helps!) - src/gitolite got a lot leaner due to this dispatcher - src/gitolite-shell became a lot more easier to read/flow - rc acquired '{COMMANDS}', which gitolite-shell now refers to - comments in the default rc file changed a bit - rc got a new REMOTE_COMMAND_PATT (in place of ADC_CMD_ARGS_PATT) the rest is perltidy and stuff like that
2012-03-12 16:24:30 +01:00
},
(lotsa files affected) rc file format changed; see below The rc file used to be a bunch of variables, each one requiring to be declared before being used. While this was nice and all, it was a little cumbersome to add a new flag or option. If you disregard the "catch typos" aspect of having to predeclare variables, it's a lot more useful to have all of rc be in a hash and use any hash keys you want. There could be other uses; for instance it could hold arbitrary data that you would currently put in %ENV, without having to pollute %ENV if you don't need child tasks to inherit it. ---- NOTE: I also ran perltidy, which I don't always remember to :)
2012-03-16 05:29:45 +01:00
);
# ------------------------------------------------------------------------------
# per perl rules, this should be the last line in such a file:
1;
# Local variables:
# mode: perl
# End:
# vim: set syn=perl:
Reference in a new issue Copy permalink