Alien::Build(3) User Contributed Perl Documentation Alien::Build(3)
NAME
Alien::Build - Build external dependencies for use in CPAN
VERSION
version 2.80
SYNOPSIS
my $build = Alien::Build->load('./alienfile');
$build->load_requires('configure');
$build->set_prefix('/usr/local');
$build->set_stage('/foo/mystage'); # needs to be absolute
$build->load_requires($build->install_type);
$build->download;
$build->build;
# files are now in /foo/mystage, it is your job (or
# ExtUtils::MakeMaker, Module::Build, etc) to copy
# those files into /usr/local
DESCRIPTION
This module provides tools for building external (non-CPAN)
dependencies for CPAN. It is mainly designed to be used at install
time of a CPAN client, and work closely with Alien::Base which is used
at runtime.
This is the detailed documentation for the Alien::Build class. If you
are starting out you probably want to do so from one of these
documents:
Alien::Build::Manual::Alien
A broad overview of "Alien-Build" and its ecosystem.
Alien::Build::Manual::AlienUser
For users of an "Alien::libfoo" that is implemented using
Alien::Base. (The developer of "Alien::libfoo" should provide the
documentation necessary, but if not, this is the place to start).
Alien::Build::Manual::AlienAuthor
If you are writing your own Alien based on Alien::Build and
Alien::Base.
Alien::Build::Manual::FAQ
If you have a common question that has already been answered, like
"How do I use alienfile with some build system".
Alien::Build::Manual::PluginAuthor
This is for the brave souls who want to write plugins that will
work with Alien::Build + alienfile.
Alien::Build::Manual::Security
If you are concerned that Aliens might be downloading tarballs off
the internet, then this is the place for you. This will discuss
some of the risks of downloading (really any) software off the
internet and will give you some tools to remediate these risks.
Note that you will not usually create a Alien::Build instance directly,
but rather be using a thin installer layer, such as Alien::Build::MM
(for use with ExtUtils::MakeMaker) or Alien::Build::MB (for use with
Module::Build). One of the goals of this project is to remain
installer agnostic.
CONSTRUCTORS
new
my $build = Alien::Build->new;
This creates a new empty instance of Alien::Build. Normally you will
want to use "load" below to create an instance of Alien::Build from an
alienfile recipe.
load
my $build = Alien::Build->load($alienfile);
This creates an Alien::Build instance with the given alienfile recipe.
resume
my $build = Alien::Build->resume($alienfile, $root);
Load a checkpointed Alien::Build instance. You will need the original
alienfile and the build root (usually "_alien"), and a build that had
been properly checkpointed using the "checkpoint" method below.
PROPERTIES
There are three main properties for Alien::Build. There are a number
of properties documented here with a specific usage. Note that these
properties may need to be serialized into something primitive like JSON
that does not support: regular expressions, code references of blessed
objects.
If you are writing a plugin (Alien::Build::Plugin) you should use a
prefix like "plugin_name" (where name is the name of your plugin) so
that it does not interfere with other plugin or future versions of
Alien::Build. For example, if you were writing
"Alien::Build::Plugin::Fetch::NewProtocol", please use the prefix
"plugin_fetch_newprotocol":
sub init
{
my($self, $meta) = @_;
$meta->prop( plugin_fetch_newprotocol_foo => 'some value' );
$meta->register_hook(
some_hook => sub {
my($build) = @_;
$build->install_prop->{plugin_fetch_newprotocol_bar} = 'some other value';
$build->runtime_prop->{plugin_fetch_newprotocol_baz} = 'and another value';
}
);
}
If you are writing a alienfile recipe please use the prefix "my_":
use alienfile;
meta_prop->{my_foo} = 'some value';
probe sub {
my($build) = @_;
$build->install_prop->{my_bar} = 'some other value';
$build->install_prop->{my_baz} = 'and another value';
};
Any property may be used from a command:
probe [ 'some command %{.meta.plugin_fetch_newprotocol_foo}' ];
probe [ 'some command %{.install.plugin_fetch_newprotocol_bar}' ];
probe [ 'some command %{.runtime.plugin_fetch_newprotocol_baz}' ];
probe [ 'some command %{.meta.my_foo}' ];
probe [ 'some command %{.install.my_bar}' ];
probe [ 'some command %{.runtime.my_baz}' ];
meta_prop
my $href = $build->meta_prop;
my $href = Alien::Build->meta_prop;
Meta properties have to do with the recipe itself, and not any
particular instance that probes or builds that recipe. Meta properties
can be changed from within an alienfile using the "meta_prop"
directive, or from a plugin from its "init" method (though should NOT
be modified from any hooks registered within that "init" method). This
is not strictly enforced, but if you do not follow this rule your
recipe will likely be broken.
arch
This is a hint to an installer like Alien::Build::MM or
Alien::Build::MB, that the library or tool contains architecture
dependent files and so should be stored in an architecture
dependent location. If not specified by your alienfile then it
will be set to true.
check_digest
True if cryptographic digest should be checked when files are
fetched or downloaded. This is set by Digest negotiator plugin.
destdir
Some plugins (Alien::Build::Plugin::Build::Autoconf for example)
support installing via "DESTDIR". They will set this property to
true if they plan on doing such an install. This helps
Alien::Build find the staged install files and how to locate them.
If available, "DESTDIR" is used to stage install files in a sub
directory before copying the files into "blib". This is generally
preferred method if available.
destdir_filter
Regular expression for the files that should be copied from the
"DESTDIR" into the stage directory. If not defined, then all files
will be copied.
destdir_ffi_filter
Same as "destdir_filter" except applies to "build_ffi" instead of
"build".
digest
This properties contains the cryptographic digests (if any) that
should be used when verifying any fetched and downloaded files. It
is a hash reference where the key is the filename and the value is
an array reference containing a pair of values, the first being the
algorithm ('SHA256' is recommended) and the second is the actual
digest. The special filename "*" may be specified to indicate that
any downloaded file should match that digest. If there are both
real filenames and the "*" placeholder, the real filenames will be
used for filenames that match and any other files will use the
placeholder. Example:
$build->meta_prop->{digest} = {
'foo-1.00.tar.gz' => [ SHA256 => '9feac593aa49a44eb837de52513a57736457f1ea70078346c60f0bfc5f24f2c1' ],
'foo-1.01.tar.gz' => [ SHA256 => '6bbde6a7f10ae5924cf74afc26ff5b7bc4b4f9dfd85c6b534c51bd254697b9e7' ],
'*' => [ SHA256 => '33a20aae3df6ecfbe812b48082926d55391be4a57d858d35753ab1334b9fddb3' ],
};
Cryptographic signatures will only be checked if the check_digest
meta property is set and if the Digest negotiator plugin is loaded.
(The Digest negotiator can be used directly, but is also loaded
automatically if you use the digest directive is used by the
alienfile).
env Environment variables to override during the build stage.
env_interpolate
Environment variable values will be interpolated with helpers.
Example:
meta->prop->{env_interpolate} = 1;
meta->prop->{env}->{PERL} = '%{perl}';
local_source
Set to true if source code package is available locally. (that is
not fetched over the internet). This is computed by default based
on the "start_url" property. Can be set by an alienfile or plugin.
platform
Hash reference. Contains information about the platform beyond
just $^O.
platform.compiler_type
Refers to the type of flags that the compiler accepts. May be
expanded in the future, but for now, will be one of:
microsoft
On Windows when using Microsoft Visual C++
unix
Virtually everything else, including gcc on windows.
The main difference is that with Visual C++ "-LIBPATH" should
be used instead of "-L", and static libraries should have the
".LIB" suffix instead of ".a".
platform.system_type
$^O is frequently good enough to make platform specific logic
in your alienfile, this handles the case when $^O can cover
platforms that provide multiple environments that Perl might
run under. The main example is windows, but others may be
added in the future.
unix
vms
windows-activestate
windows-microsoft
windows-mingw
windows-strawberry
windows-unknown
Note that "cygwin" and "msys" are considered "unix" even though
they run on windows!
platform.cpu.count
Contains a non-negative integer of available (possibly virtual)
CPUs on the system. This can be used by build plugins to build
in parallel. The environment variable "ALIEN_CPU_COUNT" can be
set to override the CPU count.
platform.cpu.arch.name
Contains a normalized name for the architecture of the current
Perl. This can be used by fetch plugins to determine which
binary packages to download. The value may be one of the
following, but this list will be expanded as needed.
"armel"
32-bit ARM soft-float
"armhf"
32-bit ARM hard-float
"aarch64"
64-bit ARM
"ppc"
32-bit PowerPC (big-endian)
"ppc64"
64-bit PowerPC (big-endian)
"x86"
32-bit Intel (i386, i486, i686)
"x86_64"
64-bit Intel (AMD64)
"unknown"
Unable to detect architecture. Please report this if
needed.
out_of_source
Build in a different directory from the where the source code is
stored. In autoconf this is referred to as a "VPATH" build.
Everyone else calls this an "out-of-source" build. When this
property is true, instead of extracting to the source build root,
the downloaded source will be extracted to an source extraction
directory and the source build root will be empty. You can use the
"extract" install property to get the location of the extracted
source.
network
True if a network fetch is available. This should NOT be set by an
alienfile or plugin. This is computed based on the
"ALIEN_INSTALL_NETWORK" environment variables.
start_url
The default or start URL used by fetch plugins.
install_prop
my $href = $build->install_prop;
Install properties are used during the install phase (either under
"share" or "system" install). They are remembered for the entire
install phase, but not kept around during the runtime phase. Thus they
cannot be accessed from your Alien::Base based module.
autoconf_prefix
The prefix as understood by autoconf. This is only different on
Windows Where MSYS is used and paths like "C:/foo" are represented
as "/C/foo" which are understood by the MSYS tools, but not by
Perl. You should only use this if you are using
Alien::Build::Plugin::Build::Autoconf in your alienfile. This is
set during before the build hook is run.
download
The location of the downloaded archive (tar.gz, or similar) or
directory. This will be undefined until the archive is actually
downloaded.
download_detail
This property contains optional details about a downloaded file.
This property is populated by Alien::Build core. This property is
a hash reference. The key is the path to the file that has been
downloaded and the value is a hash reference with additional
detail. All fields are optional.
download_detail.digest
This, if available, with the cryptographic signature that was
successfully matched against the downloaded file. It is an
array reference with a pair of values, the algorithm (typically
something like "SHA256") and the digest.
download_detail.protocol
This, if available, will be the URL protocol used to fetch the
downloaded file.
env Environment variables to override during the build stage. Plugins
are free to set additional overrides using this hash.
extract
The location of the last source extraction. For a "out-of-source"
build (see the "out_of_source" meta property above), this will only
be set once. For other types of builds, the source code may be
extracted multiple times, and thus this property may change.
old [deprecated]
Hash containing information on a previously installed Alien of the
same name, if available. This may be useful in cases where you
want to reuse the previous install if it is still sufficient.
old.prefix
[deprecated]
The prefix for the previous install. Versions prior to 1.42
unfortunately had this in typo form of "preifx".
old.runtime
[deprecated]
The runtime properties from the previous install.
patch
Directory with patches, if available. This will be "undef" if
there are no patches. When initially installing an alien this will
usually be a sibling of the "alienfile", a directory called
"patch". Once installed this will be in the share directory called
"_alien/patch". The former is useful for rebuilding an alienized
package using af.
prefix
The install time prefix. Under a "destdir" install this is the
same as the runtime or final install location. Under a
non-"destdir" install this is the "stage" directory (usually the
appropriate share directory under "blib").
root
The build root directory. This will be an absolute path. It is
the absolute form of "./_alien" by default.
stage
The stage directory where files will be copied. This is usually
the root of the blib share directory.
system_probe_class
After the probe step this property may contain the plugin class
that performed the system probe. It shouldn't be filled in
directly by the plugin (instead if should use the hook property
"probe_class", see below). This is optional, and not all probe
plugins will provide this information.
system_probe_instance_id
After the probe step this property may contain the plugin instance
id that performed the system probe. It shouldn't be filled in
directly by the plugin (instead if should use the hook property
"probe_instance_id", see below). This is optional, and not all
probe plugins will provide this information.
plugin_instance_prop
my $href = $build->plugin_instance_prop($plugin);
This returns the private plugin instance properties for a given plugin.
This method should usually only be called internally by plugins
themselves to keep track of internal state. Because the content can be
used arbitrarily by the owning plugin because it is private to the
plugin, and thus is not part of the Alien::Build spec.
runtime_prop
my $href = $build->runtime_prop;
Runtime properties are used during the install and runtime phases
(either under "share" or "system" install). This should include
anything that you will need to know to use the library or tool during
runtime, and shouldn't include anything that is no longer relevant once
the install process is complete.
alien_build_version
The version of Alien::Build used to install the library or tool.
alt Alternate configurations. If the alienized package has multiple
libraries this could be used to store the different compiler or
linker flags for each library. Typically this will be set by a
plugin in the gather stage (for either share or system installs).
cflags
The compiler flags. This is typically set by a plugin in the
gather stage (for either share or system installs).
cflags_static
The static compiler flags. This is typically set by a plugin in
the gather stage (for either share or system installs).
command
The command name for tools where the name my differ from platform
to platform. For example, the GNU version of make is usually
"make" in Linux and "gmake" on FreeBSD. This is typically set by a
plugin in the gather stage (for either share or system installs).
ffi_name
The name DLL or shared object "name" to use when searching for
dynamic libraries at runtime. This is passed into FFI::CheckLib,
so if your library is something like "libarchive.so" or
"archive.dll" you would set this to "archive". This may be a
string or an array of strings. This is typically set by a plugin
in the gather stage (for either share or system installs).
ffi_checklib
This property contains two sub properties:
ffi_checklib.share
$build->runtime_prop->{ffi_checklib}->{share} = [ ... ];
Array of additional FFI::CheckLib flags to pass in to
"find_lib" for a "share" install.
ffi_checklib.system
Array of additional FFI::CheckLib flags to pass in to
"find_lib" for a "system" install.
Among other things, useful for specifying the
"try_linker_script" flag:
$build->runtime_prop->{ffi_checklib}->{system} = [ try_linker_script => 1 ];
This is typically set by a plugin in the gather stage (for either
share or system installs).
inline_auto_include
[version 2.53]
This property is an array reference of C code that will be passed
into Inline::C to make sure that appropriate headers are
automatically included. See "auto_include" in Inline::C for
details.
install_type
The install type. This is set by AB core after the probe hook is
executed. Is one of:
system
For when the library or tool is provided by the operating
system, can be detected by Alien::Build, and is considered
satisfactory by the "alienfile" recipe.
share
For when a system install is not possible, the library source
will be downloaded from the internet or retrieved in another
appropriate fashion and built.
libs
The library flags. This is typically set by a plugin in the gather
stage (for either share or system installs).
libs_static
The static library flags. This is typically set by a plugin in the
gather stage (for either share or system installs).
perl_module_version
The version of the Perl module used to install the alien (if
available). For example if Alien::curl is installing "libcurl"
this would be the version of Alien::curl used during the install
step.
prefix
The final install root. This is usually they share directory.
version
The version of the library or tool. This is typically set by a
plugin in the gather stage (for either share or system installs).
hook_prop
my $href = $build->hook_prop;
Hook properties are for the currently running (if any) hook. They are
used only during the execution of each hook and are discarded after.
If no hook is currently running then "hook_prop" will return "undef".
name
The name of the currently running hook.
version (probe)
Probe and PkgConfig plugins may set this property indicating the
version of the alienized package. Not all plugins and
configurations may be able to provide this.
probe_class (probe)
Probe and PkgConfig plugins may set this property indicating the
plugin class that made the probe. If the probe results in a system
install this will be propagated to "system_probe_class" for later
use.
probe_instance_id (probe)
Probe and PkgConfig plugins may set this property indicating the
plugin instance id that made the probe. If the probe results in a
system install this will be propagated to
"system_probe_instance_id" for later use.
METHODS
checkpoint
$build->checkpoint;
Save any install or runtime properties so that they can be reloaded on
a subsequent run in a separate process. This is useful if your build
needs to be done in multiple stages from a "Makefile", such as with
ExtUtils::MakeMaker. Once checkpointed you can use the "resume"
constructor (documented above) to resume the probe/build/install]
process.
root
my $dir = $build->root;
This is just a shortcut for:
my $root = $build->install_prop->{root};
Except that it will be created if it does not already exist.
install_type
my $type = $build->install_type;
This will return the install type. (See the like named install
property above for details). This method will call "probe" if it has
not already been called.
download_rule
my $rule = $build->download_rule;
This returns install rule as a string. This is determined by the
environment and should be one of:
"warn"
Warn only if fetching via non secure source (secure sources include
"https", and bundled files, may include other encrypted protocols
in the future).
"digest"
Require that any downloaded source package have a cryptographic
signature in the alienfile and that signature matches what was
downloaded.
"encrypt"
Require that any downloaded source package is fetched via secure
source.
"digest_or_encrypt"
Require that any downloaded source package is either fetched via a
secure source or has a cryptographic signature in the alienfile and
that signature matches what was downloaded.
"digest_and_encrypt"
Require that any downloaded source package is both fetched via a
secure source and has a cryptographic signature in the alienfile
and that signature matches what was downloaded.
The current default is "warn", but in the near future this will be
upgraded to "digest_or_encrypt".
set_prefix
$build->set_prefix($prefix);
Set the final (unstaged) prefix. This is normally only called by
Alien::Build::MM and similar modules. It is not intended for use from
plugins or from an alienfile.
set_stage
$build->set_stage($dir);
Sets the stage directory. This is normally only called by
Alien::Build::MM and similar modules. It is not intended for use from
plugins or from an alienfile.
requires
my $hash = $build->requires($phase);
Returns a hash reference of the modules required for the given phase.
Phases include:
configure
These modules must already be available when the alienfile is read.
any These modules are used during either a "system" or "share" install.
share
These modules are used during the build phase of a "share" install.
system
These modules are used during the build phase of a "system"
install.
load_requires
$build->load_requires($phase);
This loads the appropriate modules for the given phase (see "requires"
above for a description of the phases).
probe
my $install_type = $build->probe;
Attempts to determine if the operating system has the library or tool
already installed. If so, then the string "system" will be returned
and a system install will be performed. If not, then the string
"share" will be installed and the tool or library will be downloaded
and built from source.
If the environment variable "ALIEN_INSTALL_TYPE" is set, then that will
force a specific type of install. If the detection logic cannot
accommodate the install type requested then it will fail with an
exception.
download
$build->download;
Download the source, usually as a tarball, usually from the internet.
Under a "system" install this does not do anything.
fetch
my $res = $build->fetch;
my $res = $build->fetch($url, %options);
Fetch a resource using the fetch hook. Returns the same hash structure
described below in the fetch hook documentation.
[version 2.39]
As of Alien::Build 2.39, these options are supported:
http_headers
my $res = $build->fetch($url, http_headers => [ $key1 => $value1, $key2 => $value 2, ... ]);
Set the HTTP request headers on all outgoing HTTP requests. Note
that not all protocols or fetch plugins support setting request
headers, but the ones that do not should issue a warning if you try
to set request headers and they are not supported.
check_digest
[experimental]
my $bool = $build->check_digest($path);
Checks any cryptographic signatures for the given file. The file is
specified by $path which may be one of:
string
Containing the path to the file to be checked.
Path::Tiny
Containing the path to the file to be checked.
"HASH"
A Hash reference containing information about a file. See the
fetch hook for details on the format.
Returns true if the cryptographic signature matches, false if
cryptographic signatures are disabled. Will throw an exception if the
signature does not match, or if no plugin provides the correct
algorithm for checking the signature.
decode
my $decoded_res = $build->decode($res);
Decode the HTML or file listing returned by "fetch". Returns the same
hash structure described below in the decode hook documentation.
prefer
my $sorted_res = $build->prefer($res);
Filter and sort candidates. The preferred candidate will be returned
first in the list. The worst candidate will be returned last. Returns
the same hash structure described below in the prefer hook
documentation.
extract
my $dir = $build->extract;
my $dir = $build->extract($archive);
Extracts the given archive into a fresh directory. This is normally
called internally to Alien::Build, and for normal usage is not needed
from a plugin or alienfile.
build
$build->build;
Run the build step. It is expected that "probe" and "download" have
already been performed. What it actually does depends on the type of
install:
share
The source is extracted, and built as determined by the alienfile
recipe. If there is a "gather_share" that will be executed last.
system
The gather_system hook will be executed.
test
$build->test;
Run the test phase
clean_install
$build->clean_install
Clean files from the final install location. The default
implementation removes all files recursively except for the "_alien"
directory. This is helpful when you have an old install with files
that may break the new build.
For a non-share install this doesn't do anything.
system
$build->system($command);
$build->system($command, @args);
Interpolates the command and arguments and run the results using the
Perl "system" command.
log
$build->log($message);
Send a message to the log. By default this prints to "STDOUT".
meta
my $meta = Alien::Build->meta;
my $meta = $build->meta;
Returns the meta object for your Alien::Build class or instance. The
meta object is a way to manipulate the recipe, and so any changes to
the meta object should be made before the "probe", "download" or
"build" steps.
META METHODS
prop
my $href = $build->meta->prop;
Meta properties. This is the same as calling "meta_prop" on the class
or Alien::Build instance.
add_requires
Alien::Build->meta->add_requires($phase, $module => $version, ...);
Add the requirement to the given phase. Phase should be one of:
configure
any
share
system
interpolator
my $interpolator = $build->meta->interpolator;
my $interpolator = Alien::Build->interpolator;
Returns the Alien::Build::Interpolate instance for the Alien::Build
class.
has_hook
my $bool = $build->meta->has_hook($name);
my $bool = Alien::Build->has_hook($name);
Returns if there is a usable hook registered with the given name.
register_hook
$build->meta->register_hook($name, $instructions);
Alien::Build->meta->register_hook($name, $instructions);
Register a hook with the given name. $instruction should be either a
code reference, or a command sequence, which is an array reference.
default_hook
$build->meta->default_hook($name, $instructions);
Alien::Build->meta->default_hook($name, $instructions);
Register a default hook, which will be used if the alienfile does not
register its own hook with that name.
around_hook
$build->meta->around_hook($hook_name, $code);
Alien::Build->meta->around_hook($hook_name, $code);
Wrap the given hook with a code reference. This is similar to a Moose
method modifier, except that it wraps around the given hook instead of
a method. For example, this will add a probe system requirement:
$build->meta->around_hook(
probe => sub {
my $orig = shift;
my $build = shift;
my $type = $orig->($build, @_);
return $type unless $type eq 'system';
# also require a configuration file
if(-f '/etc/foo.conf')
{
return 'system';
}
else
{
return 'share';
}
},
);
after_hook
$build->meta->after_hook($hook_name, sub {
my(@args) = @_;
...
});
Execute the given code reference after the hook. The original
arguments are passed into the code reference.
before_hook
$build->meta->before_hook($hook_name, sub {
my(@args) = @_;
...
});
Execute the given code reference before the hook. The original
arguments are passed into the code reference.
apply_plugin
Alien::Build->meta->apply_plugin($name);
Alien::Build->meta->apply_plugin($name, @args);
Apply the given plugin with the given arguments.
ENVIRONMENT
Alien::Build responds to these environment variables:
ALIEN_BUILD_LOG
The default log class used. See Alien::Build::Log and
Alien::Build::Log::Default.
ALIEN_BUILD_PKG_CONFIG
Override the logic in Alien::Build::Plugin::PkgConfig::Negotiate
which chooses the best "pkg-config" plugin.
ALIEN_BUILD_POSTLOAD
semicolon separated list of plugins to automatically load after
parsing your alienfile.
ALIEN_BUILD_PRELOAD
semicolon separated list of plugins to automatically load before
parsing your alienfile.
ALIEN_BUILD_RC
Perl source file which can override some global defaults for
Alien::Build, by, for example, setting preload and postload
plugins.
ALIEN_DOWNLOAD_RULE
This value determines the rules by which types of downloads are
allowed. The legal values listed under "download_rule", plus
"default" which will be the default for the current version of
Alien::Build. For this version that default is "warn".
ALIEN_INSTALL_NETWORK
If set to true (the default), then network fetch will be allowed.
If set to false, then network fetch will not be allowed.
What constitutes a local vs. network fetch is determined based on
the "start_url" and "local_source" meta properties. An alienfile
or plugin "could" override this detection (possibly
inappropriately), so this variable is not a substitute for properly
auditing of Perl modules for environments that require that.
ALIEN_INSTALL_TYPE
If set to "share" or "system", it will override the system
detection logic. If set to "default", it will use the default
setting for the alienfile. The behavior of other values is
undefined.
Although the recommended way for a consumer to use an Alien::Base
based Alien is to declare it as a static configure and build-time
dependency, some consumers may prefer to fallback on using an Alien
only when the consumer itself cannot detect the necessary package.
In some cases the consumer may want the user to opt-in to using an
Alien before requiring it.
To keep the interface consistent among Aliens, the consumer of the
fallback opt-in Alien may fallback on the Alien if the environment
variable "ALIEN_INSTALL_TYPE" is set to any value. The rationale is
that by setting this environment variable the user is aware that
Alien modules may be installed and have indicated consent. The
actual implementation of this, by its nature would have to be in
the consuming CPAN module.
DESTDIR
This environment variable will be manipulated during a destdir
install.
PKG_CONFIG
This environment variable can be used to override the program name
for "pkg-config" when using the command line plugin:
Alien::Build::Plugin::PkgConfig::CommandLine.
ftp_proxy, all_proxy
If these environment variables are set, it may influence the
Download negotiation plugin
Alien::Build::Plugin::Download::Negotiate. Other proxy variables
may be used by some Fetch plugins, if they support it.
SUPPORT
The intent of the "Alien-Build" team is to support the same versions of
Perl that are supported by the Perl toolchain. As of this writing that
means 5.16 and better.
Please feel encouraged to report issues that you encounter to the
project GitHub Issue tracker:
<https://github.com/PerlAlien/Alien-Build/issues>
Better if you can fix the issue yourself, please feel encouraged to
open pull-request on the project GitHub:
<https://github.com/PerlAlien/Alien-Build/pulls>
If you are confounded and have questions, join us on the "#native"
channel on irc.perl.org. The "Alien-Build" developers frequent this
channel and can probably help point you in the right direction. If you
don't have an IRC client handy, you can use this web interface:
<https://chat.mibbit.com/?channel=%23native&server=irc.perl.org>
SEE ALSO
Alien::Build::Manual::AlienAuthor(3),
Alien::Build::Manual::AlienUser(3),
Alien::Build::Manual::Contributing(3), Alien::Build::Manual::FAQ(3),
Alien::Build::Manual::PluginAuthor(3)
alienfile(3), Alien::Build::MM(3), Alien::Build::Plugin(3),
Alien::Base(3), Alien(3)
THANKS
Alien::Base was originally written by Joel Berger, the rest of this
project would not have been possible without him getting the project
started. Thanks to his support I have been able to augment the
original Alien::Base system with a reliable set of tools (Alien::Build,
alienfile, Test::Alien), which make up this toolset.
The original Alien::Base is still copyright (c) 2012-2020 Joel Berger.
It has the same license as the rest of the Alien::Build and related
tools distributed as "Alien-Build". Joel Berger thanked a number of
people who helped in in the development of Alien::Base, in the
documentation for that module.
I would also like to acknowledge the other members of the PerlAlien
github organization, Zakariyya Mughal (sivoais, ZMUGHAL) and mohawk
(ETJ). Also important in the early development of Alien::Build were
the early adopters Chase Whitener (genio, CAPOEIRAB, author of
Alien::libuv), William N. Braswell, Jr (willthechill, WBRASWELL, author
of Alien::JPCRE2 and Alien::PCRE2) and Ahmad Fatoum (a3f, ATHREEF,
author of Alien::libudev and Alien::LibUSB).
The Alien ecosystem owes a debt to Dan Book, who goes by Grinnz on IRC,
for answering question about how to use Alien::Build and friends.
AUTHOR
Author: Graham Ollis <plicease@cpan.org>
Contributors:
Diab Jerius (DJERIUS)
Roy Storey (KIWIROY)
Ilya Pavlov
David Mertens (run4flat)
Mark Nunberg (mordy, mnunberg)
Christian Walde (Mithaldu)
Brian Wightman (MidLifeXis)
Zaki Mughal (zmughal)
mohawk (mohawk2, ETJ)
Vikas N Kumar (vikasnkumar)
Flavio Poletti (polettix)
Salvador Fandino (salva)
Gianni Ceccarelli (dakkar)
Pavel Shaydo (zwon, trinitum)
Kang-min Liu (<?><?><?>, gugod)
Nicholas Shipp (nshp)
Juan Julian Merelo Guervos (JJ)
Joel Berger (JBERGER)
Petr Pisar (ppisar)
Lance Wicks (LANCEW)
Ahmad Fatoum (a3f, ATHREEF)
Jose Joaquin Atria (JJATRIA)
Duke Leto (LETO)
Shoichi Kaji (SKAJI)
Shawn Laffan (SLAFFAN)
Paul Evans (leonerd, PEVANS)
Hakon Haegland (hakonhagland, HAKONH)
nick nauwelaerts (INPHOBIA)
Florian Weimer
COPYRIGHT AND LICENSE
This software is copyright (c) 2011-2022 by Graham Ollis.
This is free software; you can redistribute it and/or modify it under
the same terms as the Perl 5 programming language system itself.
perl v5.34.1 2023-05-11 Alien::Build(3)
alien-build 2.800.0 - Generated Mon Apr 8 15:50:44 CDT 2024