diff options
Diffstat (limited to 'dh_assistant')
| -rwxr-xr-x | dh_assistant | 1449 |
1 files changed, 1449 insertions, 0 deletions
diff --git a/dh_assistant b/dh_assistant new file mode 100755 index 0000000..3d3337f --- /dev/null +++ b/dh_assistant @@ -0,0 +1,1449 @@ +#!/usr/bin/perl + +=head1 NAME + +dh_assistant - tool for supporting debhelper tools and provide introspection + +=cut + +use strict; +use warnings; +use constant EXIT_CODE_LINT_ISSUES_FOUND => 2; +use Debian::Debhelper::Dh_Lib; +use JSON::PP (); + +=head1 SYNOPSIS + +B<dh_assistant> B<I<command>> [S<I<additional options>>] + +=head1 DESCRIPTION + +B<dh_assistant> is a debhelper program that provides introspection into the +debhelper stack to assist third-party tools (e.g. linters) or third-party +debhelper implementations not using the debhelper script API (e.g., because +they are not written in Perl). + +=head1 COMMANDS + +The B<dh_assistant> supports the following commands: + +=head2 active-compat-level (AJSON) + +B<Synopsis>: B<dh_assistant> B<active-compat-level> + +Outputs information about which compat level the package is using. + +For packages without valid debhelper compatibility information (whether missing, ambiguous, +not supported or simply invalid), this command operates on a "best effort" basis and may abort +when error instead of providing data. + +The returned JSON dictionary contains the following key-value pairs: + +=over 4 + +=item active-compat-level + +The compat level that debhelper will be using. This is the same as B<DH_COMPAT> when present +or else B<declared-compat-level>. This can be B<null> when no compat level can be detected. + +=item declared-compat-level + +The compat level that the package declared as its default compat level. This can be B<null> +if the package does not declare any compat level at all. + +=item declared-compat-level-source + +Defines how the compat level was declared. This is null (for the same reason as +B<declared-compat-level>) or one of: + +=over 4 + +=item debian/compat + +The compatibility level was declared in the first line F<debian/compat> file. + +=item X-DH-Compat: <C> + +The compatibility was declared in the F<debian/control> via a the B<X-DH-Compat> +field. In the output, the B<C> is replaced by the actual compatibility level. +A full example value would be: + + X-DH-Compat: 15 + +=item Build-Depends: debhelper-compat (= <C>) + +The compatibility was declared in the F<debian/control> via a build dependency on the +B<< debhelper-compat (= <C>) >> package in the B<Build-Depends> field. In the output, +the B<C> is replaced by the actual compatibility level. A full example value would be: + + Build-Depends: debhelper-compat (= 15) + +=back + +=back + +=head2 supported-compat-levels (AJSON, CRFA) + +B<Synopsis>: B<dh_assistant> B<supported-compat-levels> + +Outputs information about which compat levels, this build of debhelper knows +about. + +This command accepts no options or arguments. + +=head2 which-build-system (AJSON) + +B<Synopsis>: B<dh_assistant> B<which-build-system> [S<I<build step>>] [S<I<build system options>>] + +Output information about which build system would be used for a particular build step. The build step +must be one of B<configure>, B<build>, B<test>, B<install> or B<clean> and must be the first argument +after B<which-build-system> when provided. If omitted, it defaults to B<configure> as it is the +most reliable step to use auto-detection on in a clean source directory. Note that build steps do not +always agree when using auto-detection - particularly if the B<configure> step has not been run. + +Additionally, the B<clean> step can also provide "surprising" results for builds that rely on +a separate build directory. In such cases, debhelper will return the first build system that +uses a separate build directory rather than the one build system that B<configure> would detect. +This is generally a cosmetic issue as both build systems are all basically a glorified +B<rm -fr builddir> and more precise detection is functionally irrelevant as far as debhelper is +concerned. + +The option accepts all debhelper build system arguments - i.e., options you can pass to all of +the B<dh_auto_*> commands plus (for the B<install> step) the B<--destdir> option. These options +affect the output and auto-detection in various ways. Passing B<-S> or B<--buildsystem> +overrides the auto-detection (as it does for B<dh_auto_*>) but it still provides introspection +into the chosen build system. + +Things that are useful to know about the output: + +=over 4 + +=item * + +The key B<build-system> is the build system that would be used by debhelper for the given +step (with the given options, debhelper compat level, environment variables and the given +working directory). When B<-S> and B<--buildsystem> are omitted, this is the result of +debhelper's auto-detection logic. + +The value is valid as a parameter for the B<--buildsystem> option. + +The special value B<none> is used to denote that no build system would be used. This value +is not present in B<--list> parameter for the B<dh_auto_*> commands, but since debhelper/12.9 +the value is accepted for the B<--buildsystem> option. + +Note that auto-detection is subject to limitations in regards to third-party build systems. +While debhelper I<does> support auto-detecting some third-party build systems, they must be +installed for the detection to work. If they are not installed, the detection logic silently +skips that build system (often resulting in B<build-system> being B<none> in the output). + +=item * + +The B<build-directory> and B<buildpath> values serve different but related purposes. The +B<build-directory> generally mirrors the B<--builddirectory> option where as B<buildpath> +is the output directory that debhelper will use. Therefore the former will often be null +when B<--builddirectory> has not been passed while the latter will generally not be null +(except when B<build-system> is B<none>). + +=item * + +The B<dest-directory> (B<--destdir>) is undefined for all build steps except the B<install> build +step (will be output as null or absent). For the same reason, B<--destdir> should only be +passed for B<install> build step. + +Note that if not specified, this value is currently null by default. + +=item * + +The B<parallel> value is subject to B<DEB_BUILD_OPTIONS>. Notably, if that does not include +the B<parallel> keyword, then B<parallel> field in the output will always be 1. + +=item * + +Most fields in the output I<can> be null. Particular if there is no build system is detected +(or when B<--buildsystem=none>). Additionally, many of the fields can be null even if there +is a build system if the build system does not use/set/define that variable. + +=back + +=head2 detect-hook-targets (AJSON) + +B<Synopsis>: B<dh_assistant> B<detect-hook-targets> + +Detects possible override targets and hook targets that L<dh(1)> might use (provided that the +relevant command is in the sequence). + +The detection is based on scanning the rules file for any target that I<might look> like a hook +target and can therefore list targets that are in fact not hook targets (or are but will never +be triggered for other reasons). + +The detection uses a similar logic for scanning the rules file and is therefore subject to +makefile conditionals (i.e., the truth value of makefile conditionals can change whether a hook +target is visible in the output of this command). In theory, you would have to setup up the +environment to look like it would during a build for getting the most accurate output. Though, +a lot of packages will not have conditional hook targets, so the "out of the box" behaviour +will work well in most cases. + +The output looks something like this: + + { + "commands-not-in-path": [ + "dh_foo" + ], + "hook-targets": [ + { + "command": "dh_strip_nondeterminism", + "is-empty": true, + "package-section-param": null, + "filename": "debian/rules", + "target-name": "override_dh_strip_nondeterminism" + }, + { + "command": "dh_foo", + "is-empty": false, + "package-section-param": "-a", + "filename": "debian/rules", + "target-name": "override_dh_foo-arch" + } + ] + } + +In more details: + +=over 4 + +=item commands-not-in-path + +This attribute lists all the commands related to hook targets, which B<dh_assistant> could B<not> +find in PATH. These are usually caused by either the command not being installed on the system +where B<dh_assistant> is run or by the command not existing at all. + +If you are using this command to verify an hook target is present, please double check that the +command is spelled correctly. + +=item hook-targets + +List over hook targets found along with additional information about them. + +=over 4 + +=item command + +Attribute that lists which command this hook target is related too. + +=item target-name + +The actual target name detected in the F<debian/rules> file. + +=item is-empty + +A boolean that determines whether L<dh(1)> will optimize the hook out at runtime (see "Completely empty targets" in +L<dh(1)>). Note that empty override targets will still cause L<dh(1)> to skip the original command. + +=item package-section-param + +This attribute defines what package selection parameter should be passed to B<dh_*> commands used +in the hook target. It can either be B<-a>, B<-i> or (if no parameter should be used) C<null>. + +=item filename + +This attribute reports which file the target was found it. In most cases, this will always be "debian/rules" +though in case of include files, the target could appear in an include file. Note this attribute is not +super reliable as L<make(1)> only reports it for targets with a "recipe" (targets with commands inside +them). When B<make> does not provide the filename, B<dh_assistant> blindly assumes the filename is +"debian/rules" (as overrides via includes is not a commonly used feature). + +Note this accuracy of this attribute is limited about what data B<dh_assistant> can read out from the +following command: + + LC_ALL=C make -Rrnpsf debian/rules debhelper-fail-me 2>/dev/null + +=back + +=back + +This command accepts no options or arguments. + + +=head2 detect-unknown-hook-targets (AJSON, LINT) + +B<Synopsis>: B<dh_assistant> B<detect-unknown-hook-targets> [--output-format=json] [command-options] + +Detects unknown and possibly misspelled override targets and hook targets in F<debian/rules> that +will most likely not be used by L<dh(1)>. + +This command differs from B<detect-hook-targets> subtly in the scope. The B<detect-hook-targets> +will list all targets that looks like hook targets whether they are applicable or not. This +command show all hook targets, for which a command cannot be found in any sequence. Accordingly, +this command is better for linting purposes whereas B<detect-hook-targets> is better if you want +to know which hook targets are present. All the limitations listed in B<detect-hook-targets> +about scanning the rules file apply equally to this command. + +This command will attempt will attempt to load any sequence add-on listed via build-dependencies +and therefore these must be installed. Additional modules can be passed via B<--with> like with +L<dh(1)> as needed. + +This command will also need one of the following perl modules to be available: +L<Text::Levenshtein>, L<Text::LevenshteinXS>, L<Text::Levenshtein::XS>. The first one can be +installed via B<apt install libtext-levenshtein-perl>. + +The text output is intended for human consumption and should be self-explanatory. Since it is +not stable, it will not be documented. The JSON output looks something like this: + + { + "unknown-hook-targets": [ + { + "target-name": "execute_before_dh_instlal", + "filename": "debian/rules", + "candidates": [ + "execute_before_dh_install" + ] + } + ] + } + +In more details: + +=over 4 + +=item unknown-hook-targets + +List of all the unknown hook targets found along with additional information about them. + +=over 4 + +=item target-name + +The actual target name detected in the file (usually F<debian/rules>). + +=item filename + +This attribute reports which file the target was found it. In most cases, this will always be "debian/rules" +though in case of include files, the target could appear in an include file. Note this attribute is not +super reliable as L<make(1)> only reports it for targets with a "recipe" (targets with commands inside +them). When B<make> does not provide the filename, B<dh_assistant> blindly assumes the filename is +"debian/rules" (as overrides via includes is not a commonly used feature). + +Note this accuracy of this attribute is limited about what data B<dh_assistant> can read out from the +following command: + + LC_ALL=C make -Rrnpsf debian/rules debhelper-fail-me 2>/dev/null + +=item candidates + +When not null and not empty, each element in this list are names for likely candidates for the +"correct" name of this target. + +=item filename + +=back + +=item issues + +If present, then it is a list of one or more reasons why this output is definitely incomplete. Each element +in the list is an object with the following keys: + +=over 4 + +=item issue + +A key defining the issue. Currently, it is always B<load-addon>, which signals that B<dh_assistant> could +not load the add-on listed in the B<addon> key. + +Parsers should assume new issue types may appear in the future. + +=item addon + +If present, it defines the name of a B<dh> sequence add-on that is related to the failure. + +=back + +=back + +This command accepts the following options: + +=over 4 + +=item B<--output-format=>I<FORMAT> + +Request a certain type of output format. Valid values are B<text> or B<json>. + +The text format is intended for human consumption and may change between versions without any +regard for machine consumption. If you want to use this command for machine consumption, please +use the JSON format. + +=item B<--no-linter-exit-code>, B<--linter-exit-code> + +These options control whether the command should exit with the linter exit code (2) or not (0) +when an unknown target is found. By default, it uses the linter exit code when an unknown target +is found. + +=item B<--with> I<addon>, B<--without> I<addon> + +These options behave the same as the L<dh(1)> options with the same name. + +=back + +=head2 list-commands (RJSON) + +B<Synopsis>: B<dh_assistant> B<list-commands> [--output-format=json] [command-options] + +Load all B<dh> sequence add-ons and extract a full list of all commands that will be invoked across +all sequences. The command makes no attempt to filter out commands that will not be run due to +override targets or due to certain sequences not being run (by B<dh> or at all). + +As the command will attempt to load all plugins, they must be installed. + +The text output is intended for human consumption and should be self-explanatory. Since it is +not stable, it will not be documented. The JSON output looks something like this: + + { + "commands": [ + { + "command": "dh_auto_build" + }, + { + "command": "dh_auto_clean" + }, + [... more commands listed here... ] + ], + "issues": [ + { + "issue": "load-addon", + "addon": "foo" + } + ] + } + +=over 4 + +=item commands + +The top level key containing the list of all commands. Each element in the list are an object and +can have the following keys: + +=over 4 + +=item command + +The name of the command. + +While most commands are resolved via PATH, a sequence add-on could register a command via a full path +(by passing the path search). If so, the command provided in this output will also use the full path. + +=back + +=item issues + +If present, then it is a list of one or more reasons why this output is definitely incomplete. Each element +in the list is an object with the following keys: + +=over 4 + +=item issue + +A key defining the issue. Currently, it is always B<load-addon>, which signals that B<dh_assistant> could +not load the add-on listed in the B<addon> key. + +Parsers should assume new issue types may appear in the future. + +=item addon + +If present, it defines the name of a B<dh> sequence add-on that is related to the failure. + +=back + +=back + +This command accepts the following options: + +=over 4 + +=item B<--output-format=>I<FORMAT> + +Request a certain type of output format. Valid values are B<text> or B<json>. + +The text format is intended for human consumption and may change between versions without any +regard for machine consumption. If you want to use this command for machine consumption, please +use the JSON format. + +=item B<--with> I<addon>, B<--without> I<addon> + +These options behave the same as the L<dh(1)> options with the same name. + +=back + +=head2 list-guessed-dh-config-files (AJSON) + +B<Synopsis>: B<dh_assistant> B<list-guessed-dh-config-files> [command-options] + +Load all B<dh> sequence add-ons, determine the full list of commands could be used by this +source package and for each command used, then attempt to I<guess> which "config files" +these commands are interested in. + +Note this command only guesses "per command config files". Standard global config files +such as F<debian/control>, F<debian/rules>, and F<debian/compat> are not included in this +output. + +As the command name implies, the resulting output is not a full list (and will never be). +The B<dh_assistant> tool have to derive this from optional metadata that commands can +choose to provide and B<dh_assistant> has no means to validate that this metadata is up +to date. + +As the command will attempt to load all plugins, they must be installed. + +The text output is intended for human consumption and should be self-explanatory. Since it is +not stable, it will not be documented. The JSON output looks something like this: + + { + "config-files": [ + { + "commands": [ + { + "command": "dh_autoreconf_clean" + } + ], + "file-type": "pkgfile", + "pkgfile": "autoreconf.before" + }, + { + "commands": [ + { + "command": "dh_installgsettings" + } + ], + "file-type": "pkgfile", + "pkgfile": "gsettings-override" + }, + # [ ... more entries here ...] + ], + "issues": [ + { + "issue": "load-addon", + "addon": "foo" + } + ] + } + + +=over 4 + +=item config-files + +The top level key containing the list of all config-files. Each element in the list are an object and +can have the following keys: + +=over 4 + +=item file-type + +The type of config file detected. At the time of writing, this will always be B<pkgfile>. However, +other values may appear in the future. + +The B<pkgfile> key means that the config file is a B<debhelper pkgfile> (named after the B<pkgfile> sub +in L<Debian::Debhelper::Dh_Lib> that locates the file). + +=item pkgfile + +When B<file-type> is B<pkgfile>, this key defines the name stem of the B<pkgfile>. An example, this will +be B<install> for L<dh_install(1)>'s config file and B<docs> for L<dh_installdocs(1)>'s config file. + +When B<file-type> is B<not> B<pkgfile>, then this key will be absent. + +Typically names for these files are: + + debian/PKGFILE + debian/PACKAGE.PKGFILE + +However, there are more variants caused by B<--name> plus architecture specific suffixes. + +=item internal + +This key may exist and any value for it is not standardized. Use at own peril. + +It used for document certain specific implementation details such as bug compatibility and may change +as the situation changes. + +=item commands + +This key will be a list with each element in it being an object with the following keys: + +=over 4 + +=item command + +Name of the command that is interested in this config file. Multiple commands can be interested in the same +config file. An example of this would be B<dh_installinit>, B<dh_installsystemd> and B<dh_installtmpfiles>, +which all reacts to (the now) deprecated B<tmpfile> pkgfile. In the particular case, only one command reacts +to the file for a given compat level (but that information is not available to B<dh_assistant> and therefore +is not available in this output either). + +=back + +=back + +=item issues + +If present, then it is a list of one or more reasons why this output is definitely incomplete. Each element +in the list is an object with the following keys: + +=over 4 + +=item issue + +A key defining the issue. Currently, it is always B<load-addon>, which signals that B<dh_assistant> could +not load the add-on listed in the B<addon> key. + +Parsers should assume new issue types may appear in the future. + +=item addon + +If present, it defines the name of a B<dh> sequence add-on that is related to the failure. + +=back + +=back + +This command accepts the following options: + +=over 4 + +=item B<--with> I<addon>, B<--without> I<addon> + +These options behave the same as the L<dh(1)> options with the same name. + +=back + +=head2 log-installed-files (BLD) + +B<Synopsis>: B<dh_assistant> B<log-installed-files> B<< -pI<pkg> >> I<[--on-behalf-of-cmd=dh_foo]> B<path ...> + +Mark one or more paths as installed for a given package. This is useful for telling L<dh_missing(1)> that the +paths have been installed manually. + +The B<--on-behalf-of-cmd> option can be used by third-party tools to have B<dh_assistant> list them as the +installer of the provided paths. The convention is to use the basename of the tool itself as its name +(e.g. B<dh_install>). + +Please keep in mind that: + +=over 4 + +=item * + +B<No> glob or substitution expansion is done by B<dh_assistant> on the provided paths. If you want to use globs, +have the shell perform the expansion first. + +=item * + +Paths must be given as relative to the source root directory (e.g., F<debian/tmp/...>) + +=item * + +You I<can> provide a directory. If you do, the directory and anything recursively below it will be considered +as installed. Note that it is fine to provide the directory even if paths inside of it has been excluded as long +as the directory is fully "covered". + +=item * + +Do not worry about providing the same filename twice in different invocations to B<dh_assistant> due to B<-arch> / +B<-indep> overrides. While it will be recorded multiple internally, L<dh_missing(1)> will deduplicate when it +parses the records. + +=back + +Note this command only I<marks> paths as installed. It does not actually install them - the caller should ensure +that the paths are in fact handled (or installed). + +=head2 restore-file-on-clean (BLD) + +B<Synopsis>: B<dh_assistant> B<restore-file-on-clean> B<FILE ...> + +This command will take a backup of listed files and tell L<dh_clean(1)> to restore them when it runs. + +Note that generally you do not need to restore modified files on clean. Often you can get away with just +removing them if they are regenerated anyway (which is the most common case for files being modified during +builds). Use this command when something taints a file and the build does not cope with the file being +removed. + +The file is stored in B<debian/.debhelper>. If you remove this directory manually without calling +L<dh_clean(1)> then your B<dh_assistant> provided backup is gone permanently and the restore will never +occur. At this point, only a version control system or another backup can restore the files. + +The command has the following limitations: + +=over 4 + +=item No thread-safety - concurrency will corrupt the restore + +The command relies on updating an internal index and concurrent writes will cause it to be corrupt. + +While most B<dh_*> commands does not use the underlying function, any of them could do so. Avoid running +another B<dh_*> command while B<dh_assistant> processes this command (especially running multiple concurrent +instances of B<dh_assistant restore-file-on-clean> is asking for corruption!). + +=item Files only, not directories nor symlinks to files + +This command will only restore files; not directories or symlinks to files. It will reject any non-files. + +Additionally, if the directory containing the file is removed, the restore will fail (as B<debhelper> +does not track the directory, it cannot restore it reliably). If this happens, you can do a B<mkdir> +to restore the directory and run L<dh_clean(1)> again to get the files back. After that, consider +what went wrong and whether you are using the correct tool(s). + +=item Strict file names + +All filenames must be relative to the package root (without using the B<./> prefix). No hidden files (that +is any file starting with a period B<.>) and no version control directories (such as B<CVS>). The checks +are best effort. + +These checks are here to ensure you do not accidentally trash important data that would help you undo +mistakes. + +=item Heavy duty + +The command takes a B<full copy> of all files you pass it. This is fine for a handful of small files, +which is the intended use-case. If you find yourself passing 10+ files or very large files, you might +be applying a sledgehammer where you needed a different tool. + +=back + +=head2 supports (CFFA) + +B<Synopsis>: B<dh_assistant> B<supports> B<COMMAND> + +This command is a scripting aid to programmatically determine whether B<dh_assistant> knows about a given +subcommand. Pass the name of a subcommand and this command will exit successfully if the subcommand was known +and unsuccessfully otherwise. + +=head1 COMMAND TAGS + +Most commands have one or more of the following "tags" associated with them. Their +meaning is defined here. + +=over 4 + +=item AJSON + +The command always provides JSON output. See L</JSON OUTPUT> for details. + +=item OJSON + +The command *can* provide JSON output via B<--output-format=json>, but does not +do so by default. See L</JSON OUTPUT> for details when using B<--output-format=json>. + +=item LINT + +The command is or can be used for linting purposes. This command will exit with code 2 when an important +issue is found. + +Note that commands may have options that redefine what is considered an "important" issue. + +=item CRFA + +I<Mnemonic "Can be Run From Anywhere"> + +Most commands must be run inside a source package root directory (a directory +containing F<debian/control>) because debhelper will need the package metadata +to lookup the information. Any command with this tag are exempt from this +requirement and is expected to work regardless of where they are run. + +=item BLD + +The command is intended to be used as a part of a package build. It may leave +artifacts behind that will need a L<dh_clean(1)> invocation to remove. + +=back + +=head1 JSON OUTPUT + +Most commands uses JSON format as output. Consumers need to be aware that: + +=over 4 + +=item * + +Additional keys may be added at any time. For backwards compatibility, the absence +of a key should in general be interpreted as null unless another default is documented +or would be "obvious" for that case. + +=item * + +Many keys can be null/undefined in special cases. As an example, some information may +be unavailable when this command is run directly from the debhelper source (git repository). + +=back + +The output will be prettified when stdout is detected as a terminal. If +you need to pipe the output to a pager/file (etc.) and still want it +prettified, please use an external JSON formatter. An example of this: + + dh_assistant supported-compat-levels | json_pp | less + +=cut + +my $JSON_ENCODER = JSON::PP->new->utf8; + +# Prettify if we think the user is reading this. +$JSON_ENCODER = $JSON_ENCODER->pretty->space_before(0)->canonical if -t STDOUT; + +# We never use the log file for this tool +inhibit_log(); +$Debian::Debhelper::Dh_Lib::PARSE_DH_SEQUENCE_INFO = 1; + +my %COMMANDS = ( + 'help' => \&_do_help, + '-h' => \&_do_help, + '--help' => \&_do_help, + 'active-compat-level' => \&active_compat_level, + 'supported-compat-levels' => \&supported_compat_levels, + 'which-build-system' => \&which_build_system, + 'detect-hook-targets' => \&detect_hook_targets, + 'detect-unknown-hook-targets' => \&detect_unknown_hook_targets, + 'list-commands' => \&list_commands, + 'list-guessed-dh-config-files' => \&list_guessed_dh_config_files, + 'log-installed-files' => \&log_installed_files_cmd, + 'restore-file-on-clean' => \&dh_assistant_restore_file_on_clean, + 'supports' => \&supports, +); + +my ($COMMAND) = shift(@ARGV); +for my $arg (@ARGV) { + if ($arg eq '--help' or $arg eq '-h') { + $COMMAND = 'help'; + last; + } +} + + +sub _do_help { + my $me = basename($0); + print <<"EOF"; +${me}: Tool for supporting debhelper tools and provide introspection + +Usage: ${me} <command> [... addition arguments or options ...] + +The following commands are available: + help Show this help + active-compat-level Output information about which compat level is declared/active (AJSON) + supported-compat-levels Output information about supported compat levels (AJSON, CRFA) + which-build-system Determine which build system will be used (AJSON) + detect-hook-targets Detect and output possible override and hook targets (AJSON) + detect-unknown-hook-targets + Detect unknown / typos of known hook targets (RJSON) + list-commands List all commands across all sequences (RJSON) + list-guessed-dh-config-files + List guessed "config files" for debhelper commands (AJSON) + log-installed-files Mark one or more paths as "installed" so dh_missing is aware (BLD) + restore-file-on-clean Mark one or more files as to be restored by dh_clean (BLD) + supports Script aid: Test whether dh_assistant knows a particular command (CRFA) + +Command tags: + + * AJSON The command always provides JSON output. + * RJSON The command *can* provide JSON output via --output-format=json. + * LINT The command is or can be used for linting purposes. This command will exit with code 2 + when an important issue is found. + * CRFA Command does not need to be run from a package source directory + (Mnemonic "Can be Run From Anywhere") + * BLD The command is intended to be used as a part of a package build. + It may leave artifacts behind that will need a dh_clean invocation to remove. + + +Its primary purpose is to provide support for third-party debhelper implementations +not using the debhelper script API or provide introspection for third-party tools +(e.g., linters). Unless stated otherwise, commands must be run inside a source +package root directory - that is, the directory containing "debian/control". + +Most commands use or can provide JSON output. When stdout is a TTY, the JSON will be +prettified. See the manpage if you want formatting in other cases. +EOF + return; +} + +sub _assert_debian_control_exists { + return if -f 'debian/control'; + require Cwd; + my $cwd = Cwd::getcwd(); + warning("$cwd does not look like a package source directory (expected $cwd/debian/control to exist and be a file)"); + error("$COMMAND must be run inside a package source directory"); + return; +} + +sub _output { + my ($kvpairs) = @_; + print $JSON_ENCODER->encode($kvpairs); + return; +} + +sub active_compat_level { + if (@ARGV) { + error("$COMMAND: No arguments supported (please remove everything after the command)"); + } + _assert_debian_control_exists(); + my ($active_compat, $declared_compat, $declared_compat_source) = Debian::Debhelper::Dh_Lib::get_compat_info(); + if (not defined($declared_compat_source)) { + $declared_compat = undef; + $active_compat = undef if not exists($ENV{DH_COMPAT}); + } + my %compat_info = ( + 'active-compat-level' => $active_compat, + 'declared-compat-level' => $declared_compat, + 'declared-compat-level-source' => $declared_compat_source, + ); + _output(\%compat_info); + return; +} + +sub supported_compat_levels { + if (@ARGV) { + error("$COMMAND: No arguments supported (please remove everything after the command)"); + } + my %compat_levels = ( + 'MIN_COMPAT_LEVEL' => Debian::Debhelper::Dh_Lib::MIN_COMPAT_LEVEL, + 'LOWEST_NON_DEPRECATED_COMPAT_LEVEL' => Debian::Debhelper::Dh_Lib::LOWEST_NON_DEPRECATED_COMPAT_LEVEL, + 'LOWEST_VIRTUAL_DEBHELPER_COMPAT_LEVEL' => Debian::Debhelper::Dh_Lib::LOWEST_VIRTUAL_DEBHELPER_COMPAT_LEVEL, + 'MAX_COMPAT_LEVEL' => Debian::Debhelper::Dh_Lib::MAX_COMPAT_LEVEL, + 'HIGHEST_STABLE_COMPAT_LEVEL' => Debian::Debhelper::Dh_Lib::HIGHEST_STABLE_COMPAT_LEVEL, + 'MIN_COMPAT_LEVEL_NOT_SCHEDULED_FOR_REMOVAL' => Debian::Debhelper::Dh_Lib::MIN_COMPAT_LEVEL_NOT_SCHEDULED_FOR_REMOVAL, + ); + _output(\%compat_levels); + return; +} + +sub which_build_system { + my ($opt_buildsys, $destdir); + my $first_argv = @ARGV ? $ARGV[0] : ''; + my %options = ( + # Emulate dh_auto_install's --destdir + "destdir=s" => \$destdir, + ); + _assert_debian_control_exists(); + # We never want the build system initialization to modify anything (e.g. create "HOME") + $dh{NO_ACT} = 1; + require Debian::Debhelper::Dh_Buildsystems; + Debian::Debhelper::Dh_Buildsystems::buildsystems_init(options => \%options); + my @non_options = grep { !m/^-/ } @ARGV; + my $step = @non_options ? $non_options[0] : 'configure'; + if (@non_options && $first_argv =~ m/^-/) { + error("$COMMAND: If the build step is provided, it must be before any options"); + } + if (@non_options > 1) { + error("$COMMAND: At most one positional argument is supported"); + } + if (defined($destdir) and $step ne 'install') { + warning("$COMMAND: --destdir is not defined for build step \"$step\". Ignoring option") + } + { + no warnings qw(once); + $opt_buildsys = $Debian::Debhelper::Dh_Buildsystems::opt_buildsys; + } + my $build_system = Debian::Debhelper::Dh_Buildsystems::load_buildsystem($opt_buildsys, $step); + my %result = ( + 'build-system' => defined($build_system) ? $build_system->NAME : 'none', + 'for-build-step' => $step, + 'source-directory' => defined($build_system) ? $build_system->get_sourcedir : undef, + 'build-directory' => defined($build_system) ? $build_system->get_builddir : undef, + 'dest-directory' => defined($build_system) ? $destdir : undef, + 'buildpath' => defined($build_system) ? $build_system->get_buildpath : undef, + 'parallel' => defined($build_system) ? $build_system->get_parallel : undef, + 'upstream-arguments' => $dh{U_PARAMS}, + ); + _output(\%result); + return; +} + +sub _in_path { + my ($cmd) = @_; + for my $dir (split(':', $ENV{PATH})) { + return 1 if -x "${dir}/${cmd}"; + } + return 0; +} + +sub _load_hook_targets { + require Debian::Debhelper::SequencerUtil; + Debian::Debhelper::SequencerUtil::rules_explicit_target('does-not-matter'); + my ($explicit_targets); + { + no warnings qw(once); + $explicit_targets = \%Debian::Debhelper::SequencerUtil::EXPLICIT_TARGETS; + } + return $explicit_targets; +} + +sub _hook_target_variants { + my ($name) = @_; + my @base = ( + "override_${name}", + "execute_before_${name}", + "execute_after_${name}", + ); + return map { + ( + $_, + "${_}-arch", + "${_}-indep", + ) + } @base; +} + + +sub _load_levenshtein { + my @modules = (qw( + Text::LevenshteinXS + Text::Levenshtein::XS + Text::Levenshtein + )); + my $err; + for my $module (@modules) { + my $distance_func = eval "use $module (); \\&${module}::distance"; + $err = $@; + if (defined($distance_func)) { + return $distance_func; + } + } + my $module_names = join(', ', @modules); + warning("Could not load any of the modules ${module_names}"); + warning("Usually, `apt install libtext-levenshtein-perl` will fix this problem."); + error("This subcommand requires one of the following modules to be available: ${module_names}. Last failure was: $@"); +} + + +sub _all_sequence_commands { + my ($forgive_errors, @addon_requests) = @_; + my ($sequences, @all_commands, @unloadable); + Debian::Debhelper::SequencerUtil::load_sequence_addon('root-sequence', 'both'); + my @addons = Debian::Debhelper::SequencerUtil::compute_selected_addons('binary', @addon_requests); + # Load addons, which can modify sequences. + foreach my $addon (@addons) { + my $addon_name = $addon->{'name'}; + my $addon_type = $addon->{'addon-type'}; + eval { + Debian::Debhelper::SequencerUtil::load_sequence_addon($addon_name, $addon_type); + }; + if (my $err = $@) { + die($err) if not $forgive_errors; + push(@unloadable, $addon_name); + } + } + { + no warnings qw(once); + $sequences = \%Debian::Debhelper::DH::SequenceState::sequences; + } + my %seen; + for my $sequence(values(%{$sequences})) { + my @commands = map {$_->[0]} $sequence->flatten_sequence('both', 0); + for my $command (@commands) { + next if $command =~ m{^(?:debian/rules|create-stamp)}; + next if exists($seen{$command}); + $seen{$command} = 1; + push(@all_commands, $command); + } + } + return \@all_commands, \@unloadable; +} + +sub list_commands { + _assert_debian_control_exists(); + require Getopt::Long; + Getopt::Long::config('no_ignore_case'); + require Debian::Debhelper::SequencerUtil; + my $output_format = "text"; + my (@addon_requests); + my %options=( + "output-format=s" => \$output_format, + "with=s" => sub { + my ($option, $value) = @_; + push(@addon_requests, map { "+${_}" } split(",", $value)); + }, + "without=s" => sub { + my ($option, $value) = @_; + push(@addon_requests, map { "-${_}" } split(",", $value)); + }, + ); + Getopt::Long::GetOptionsFromArray(\@ARGV, %options) + or error("Could not parse the arguments"); + + if (@ARGV) { + my $value = $ARGV[0]; + error("$COMMAND: No non-options supported - please remove ${value}"); + } + + my ($all_commands, $unloadables) = _all_sequence_commands(1, @addon_requests); + if ($output_format eq 'json') { + my @commands_json; + for my $command (sort(@{$all_commands})) { + push(@commands_json, { + 'command' => $command, + }); + } + my %result = ( + "commands" => \@commands_json, + ); + if (@{$unloadables}) { + my @issues; + for my $addon (@{$unloadables}) { + push(@issues, { + "issue" => "load-addon", + "addon" => $addon, + }); + }; + $result{'issues'} = \@issues; + } + _output(\%result); + } elsif ($output_format eq 'text') { + print("Commands present in at least one sequence for this source package (sorted by name):\n"); + for my $command (sort(@{$all_commands})) { + print("\t${command}\n"); + } + if (@{$unloadables}) { + my $addon_names = join(" ", @{$unloadables}); + print("\n"); + warning("Incomplete result. The following sequence add-ons could not be loaded: $addon_names"); + } + } else { + error("Internal error: Missing case for ${output_format}"); + } +} + +sub _extract_annotations { + my ($command) = @_; + my @annotations; + + foreach my $dir (split(':', $ENV{PATH})) { + if (open (my $h, "<", "$dir/$command")) { + while (<$h>) { + if (m/PROMISE: DH NOOP( WITHOUT\s+(.*))?\s*$/) { + if (defined($2)) { + push(@annotations, split(' ', $2)); + } else { + push(@annotations, 'always-skip'); + } + } + if (m/INTROSPECTABLE: CONFIG-FILES\s+(.*)\s*$/) { + push(@annotations, split(' ', $1)); + } + } + close $h; + return @annotations; + } + } + return; +} + +sub list_guessed_dh_config_files { + _assert_debian_control_exists(); + require Getopt::Long; + Getopt::Long::config('no_ignore_case'); + require Debian::Debhelper::SequencerUtil; + my (@addon_requests); + my %options=( + "with=s" => sub { + my ($option, $value) = @_; + push(@addon_requests, map { "+${_}" } split(",", $value)); + }, + "without=s" => sub { + my ($option, $value) = @_; + push(@addon_requests, map { "-${_}" } split(",", $value)); + }, + ); + Getopt::Long::GetOptionsFromArray(\@ARGV, %options) + or error("Could not parse the arguments"); + + if (@ARGV) { + my $value = $ARGV[0]; + error("$COMMAND: No non-options supported - please remove ${value}"); + } + + my ($all_commands, $unloadables) = _all_sequence_commands(1, @addon_requests); + my $pkg_files = {}; + my $bug_950723; + for my $command (@{$all_commands}) { + my @annotations = _extract_annotations($command); + next if not @annotations or $annotations[0] eq 'always-skip'; + for my $annotation (@annotations) { + my $type = 'pkgfile'; + my $need = $annotation; + if ($annotation =~ m/^([a-zA-Z0-9-_]+)\((.*)\)$/) { + ($type, $need) = ($1, $2); + } + if ($type eq 'internal') { + $bug_950723 = 1 if $need eq 'bug#950723'; + } + next if $type ne 'pkgfile' and $type ne 'pkgfile-logged'; + my $key = "pkgfile/${need}"; + my $existing = $pkg_files->{$key}; + if (defined($existing)) { + push(@{$existing->{'commands'}}, { + 'command' => $command, + }); + } else { + $existing = { + 'file-type' => 'pkgfile', + 'pkgfile' => $need, + 'commands' => [{ + 'command' => $command, + }], + }; + $pkg_files->{$key} = $existing; + } + if ($bug_950723) { + $existing->{"internal"}{"bug#950723"} = JSON::PP::true; + } + } + } + + my @config_files = values(%{$pkg_files}); + my %result = ( + "config-files" => \@config_files, + ); + if (@{$unloadables}) { + my @issues; + for my $addon (@{$unloadables}) { + push(@issues, { + "issue" => "load-addon", + "addon" => $addon, + }); + }; + $result{'issues'} = \@issues; + } + _output(\%result); +} + + +sub detect_unknown_hook_targets { + _assert_debian_control_exists(); + my $distance_func = _load_levenshtein(); + require Getopt::Long; + Getopt::Long::config('no_ignore_case'); + require Debian::Debhelper::SequencerUtil; + my $output_format = "text"; + my (@addon_requests, %all_overrides, %unknown_hooks); + my $lint_exit = 1; + my %options=( + "output-format=s" => \$output_format, + "linter-exit-code!" => \$lint_exit, + "with=s" => sub { + my ($option, $value) = @_; + push(@addon_requests, map { "+${_}" } split(",", $value)); + }, + "without=s" => sub { + my ($option, $value) = @_; + push(@addon_requests, map { "-${_}" } split(",", $value)); + }, + ); + + Getopt::Long::GetOptionsFromArray(\@ARGV, %options) + or error("Could not parse the arguments"); + if ($output_format ne 'text' and $output_format ne 'json') { + error("--output-format must be either text or json\n"); + } + if (@ARGV) { + my $value = $ARGV[0]; + error("$COMMAND: No non-options supported - please remove ${value}"); + } + my $explicit_targets = _load_hook_targets(); + my %missing_targets = map { + $_ => 1 + } grep { + $_ ne 'debhelper-fail-me' and !m{^(?:debian/rules|create-stamp)} + } keys(%{$explicit_targets}); + + my ($all_commands, $unloadables) = _all_sequence_commands(1, @addon_requests); + for my $command (@{$all_commands}) { + for my $variant (_hook_target_variants($command)) { + $all_overrides{$variant} = 1; + delete($missing_targets{$variant}); + } + } + my @variants = sort(keys(%all_overrides)); + for my $target (keys(%missing_targets)) { + my @closest_variants; + my $closest_variant_distance = 9999; + for my $variant (@variants) { + next if abs(length($target) - length($variant)) > 3; + my $dist = $distance_func->($target, $variant); + next if $dist > $closest_variant_distance or $dist > 3; + if ($dist < $closest_variant_distance) { + $closest_variant_distance = $dist; + @closest_variants = (); + } + push(@closest_variants, $variant); + } + next if not @closest_variants and $target !~ m{^(?:override|execute_before|execute_after)_}; + @closest_variants = sort(@closest_variants); + $unknown_hooks{$target} = \@closest_variants; + } + + if ($output_format eq 'json') { + my @hook_target_data; + for my $target (sort(keys(%unknown_hooks))) { + my $options = $unknown_hooks{$target}; + my (undef, $filename) = @{$explicit_targets->{$target}}; + push(@hook_target_data, { + 'target-name' => $target, + 'filename' => $filename, + 'candidates' => $options, + }); + } + my %result = ( + "unknown-hook-targets" => \@hook_target_data, + ); + if (@{$unloadables}) { + my @issues; + for my $addon (@{$unloadables}) { + push(@issues, { + "issue" => "load-addon", + "addon" => $addon, + }); + }; + $result{'issues'} = \@issues; + } + _output(\%result); + } elsif ($output_format eq 'text') { + for my $target (sort(keys(%unknown_hooks))) { + my $options = $unknown_hooks{$target}; + my (undef, $filename) = @{$explicit_targets->{$target}}; + my $help = ''; + if (@{$options}) { + if (scalar(@{$options}) == 1) { + my $name = $options->[0]; + $help = " Likely a typo of ${name}"; + } else { + my $names = join(', ', @{$options}); + $help = " Likely a typo of one of ${names}"; + } + } + print("The hook target ${target} in ${filename} does not seem to match any known commands. ${help}\n"); + } + if (@{$unloadables}) { + my $addon_names = join(" ", @{$unloadables}); + print("\n"); + warning("Incomplete result. The following sequence add-ons could not be loaded: $addon_names"); + } + } else { + error("Internal error: Missing case for ${output_format}"); + } + if ($lint_exit && (%unknown_hooks or @{$unloadables})) { + exit(EXIT_CODE_LINT_ISSUES_FOUND); + } + exit(0); +} + +sub detect_hook_targets { + if (@ARGV) { + error("$COMMAND: No arguments supported (please remove everything after the command)"); + } + _assert_debian_control_exists(); + my $explicit_targets = _load_hook_targets(); + my (%result, @targets, @unverifiable_commands, %seen_cmds); + while (my ($target, $rule_details) = each(%{$explicit_targets})) { + next if $target !~ m{^(?:execute_before_|execute_after_|override_)(\S+?)(-indep|-arch)?$}; + my ($command, $archness) = ($1, $2); + my $param; + if ($archness) { + $param = ($archness eq '-arch') ? '-a' : '-i' ; + } + my ($non_empty, $filename) = @{$rule_details}; + + my $target_info = { + 'target-name' => $target, + 'command' => $command, + 'package-section-param' => $param, + 'is-empty' => $non_empty ? JSON::PP::false : JSON::PP::true, + 'filename' => $filename, + }; + push(@targets, $target_info); + push(@unverifiable_commands, $command) if not exists($seen_cmds{$command}) and not _in_path($command); + $seen_cmds{$command} = 1; + } + $result{'hook-targets'} = \@targets; + $result{'commands-not-in-path'} = \@unverifiable_commands; + _output(\%result); +} + +sub dh_assistant_restore_file_on_clean { + init(inhibit_log => 1); + if (not @ARGV) { + error("At least one file name is required"); + } + for my $file (@ARGV) { + lstat($file); + if ( ! -f _ ) { + error("The path ${file} was a symlink. It must be a file; not a symlink to a file") if -l _; + error("The path ${file} does not exist") if not -e _; + error("The path ${file} was not a file and this command only supports files"); + } + if ($file =~ m{[.][.]}) { + # Someone can provide a patch when there is a use-case for "..foo". + # Said patch will need to ensure the file is inside the package root dir. + error("Files containing \"..\" (which ${file} does) are not supported."); + } + if ($file =~ m{^/}) { + error("Files must be relative to the package root (which ${file} was not)") + } + if ($file =~ m{^\.} or $file =~ m{/CVS/} or $file =~ m{/\.}) { + error("Cowardly refusing to track hidden files / version control files (${file})."); + } + Debian::Debhelper::Dh_Lib::restore_file_on_clean($file) + } +} + +sub log_installed_files_cmd { + my $on_behalf_of = 'manually-via-dh_assistant'; + init( + options => { + 'on-behalf-of-cmd=s' => \$on_behalf_of, + }, + inhibit_log => 1, + ); + if (index($on_behalf_of, '/') >= 0) { + error('The value for --on-behalf-of-cmd must not contain slashes'); + } + if (@{$dh{DOPACKAGES}} != 1) { + error('The log-installed-files command must act on exactly one package (use -p<pkg> to define which)'); + } + my $package = $dh{DOPACKAGES}[0]; + for my $arg (@ARGV) { + $arg =~ tr:/:/:s; + if (! -e $arg) { + warning("The path ${arg} does not exist - double check it is correct. Note: it will recorded anyway."); + } + } + log_installed_files({ + 'package' => $package, + 'tool_name' => $on_behalf_of, + }, @ARGV); +} + +sub supports { + my ($command, @more) = @ARGV; + if (@more or not defined($command)) { + error("$COMMAND: Please provide exactly one argument"); + } + exit(0) if exists($COMMANDS{$command}); + exit(2); +} + +if (not defined($COMMAND)) { + error('Usage: ' . basename($0) . ' <command>'); +} +my $handler = $COMMANDS{$COMMAND}; +if (not defined($handler)) { + warning("Arguments/options must not be the first argument (except for --help)") + if $COMMAND =~ m/^-/; + my $available_cmds = join(' ', sort(grep { $_ ne '-h' and $_ ne '--help' and $_ ne 'help' } keys(%COMMANDS))); + error("Unknown command: $COMMAND. Use \"help\" or \"--help\" as first argument for usage. Available commands: ${available_cmds}"); +} + +$handler->(); + +=head1 SEE ALSO + +L<debhelper(7)> + +This program is a part of debhelper. + +=cut + +1; |