App-Info
view release on metacpan or search on metacpan
lib/App/Info/RDBMS/PostgreSQL.pm view on Meta::CPAN
=item search_createlang_names
=item search_createuser_names
=item search_dropd_names
=item search_droplang_names
=item search_dropuser_names
=item search_initdb_names
=item search_pg_dump_names
=item search_pg_dumpall_names
=item search_pg_restore_names
=item search_postmaster_names
=item search_psql_names
=item search_vacuumdb_names
=back
B<Events:>
=over 4
=item info
Looking for pg_config
=item confirm
Path to pg_config?
=item unknown
Path to pg_config?
=back
=cut
sub new {
# Construct the object.
my $self = shift->SUPER::new(@_);
# Find pg_config.
$self->info("Looking for pg_config");
my @paths = $self->search_bin_dirs;
my @exes = $self->search_exe_names;
if (my $cfg = $u->first_cat_exe(\@exes, @paths)) {
# We found it. Confirm.
$self->{pg_config} = $self->confirm( key => 'path to pg_config',
prompt => "Path to pg_config?",
value => $cfg,
callback => sub { -x },
error => 'Not an executable');
} else {
# Handle an unknown value.
$self->{pg_config} = $self->unknown( key => 'path to pg_config',
prompt => "Path to pg_config?",
callback => sub { -x },
error => 'Not an executable');
}
# Set up search defaults.
for my $exe (@EXES) {
my $attr = "search_$exe\_names";
if (exists $self->{$attr}) {
$self->{$attr} = [$self->{$attr}] unless ref $self->{$attr} eq 'ARRAY';
} else {
$self->{$attr} = [];
}
}
return $self;
}
# We'll use this code reference as a common way of collecting data.
my $get_data = sub {
return unless $_[0]->{pg_config};
$_[0]->info(qq{Executing `"$_[0]->{pg_config}" $_[1]`});
my $info = `"$_[0]->{pg_config}" $_[1]`;
chomp $info;
return $info;
};
##############################################################################
=head2 Class Method
=head3 key_name
my $key_name = App::Info::RDBMS::PostgreSQL->key_name;
Returns the unique key name that describes this class. The value returned is
the string "PostgreSQL".
=cut
sub key_name { 'PostgreSQL' }
##############################################################################
=head2 Object Methods
=head3 installed
print "PostgreSQL is ", ($pg->installed ? '' : 'not '), "installed.\n";
Returns true if PostgreSQL is installed, and false if it is not.
App::Info::RDBMS::PostgreSQL determines whether PostgreSQL is installed based
on the presence or absence of the F<pg_config> application on the file system
as found when C<new()> constructed the object. If PostgreSQL does not appear
to be installed, then all of the other object methods will return empty
values.
=cut
sub installed { return $_[0]->{pg_config} ? 1 : undef }
lib/App/Info/RDBMS/PostgreSQL.pm view on Meta::CPAN
return unless $self->{pg_config};
# Load data.
$get_version->($self) unless exists $self->{'--version'};
# Handle an unknown value.
$self->{patch} = $self->unknown( key => 'postgres patch version number',
callback => $is_int)
unless defined $self->{patch};
return $self->{patch};
}
##############################################################################
=head3 executable
my $exe = $pg->executable;
Returns the full path to the PostgreSQL server executable, which is named
F<postgres>. This method does not use the executable names returned by
C<search_exe_names()>; those executable names are used to search for
F<pg_config> only (in C<new()>).
When it called, C<executable()> checks for an executable named F<postgres> in
the directory returned by C<bin_dir()>.
Note that C<executable()> is simply an alias for C<postgres()>.
B<Events:>
=over 4
=item info
Looking for postgres executable
=item confirm
Path to postgres executable?
=item unknown
Path to postgres executable?
=back
=cut
my $find_exe = sub {
my ($self, $key) = @_;
my $exe = $key . (WIN32 ? '.exe' : '');
my $meth = "search_$key\_names";
# Find executable.
$self->info("Looking for $key");
unless ($self->{$key}) {
my $bin = $self->bin_dir or return;
if (my $exe = $u->first_cat_exe([$self->$meth(), $exe], $bin)) {
# We found it. Confirm.
$self->{$key} = $self->confirm(
key => "path to $key",
prompt => "Path to $key executable?",
value => $exe,
callback => sub { -x },
error => 'Not an executable'
);
} else {
# Handle an unknown value.
$self->{$key} = $self->unknown(
key => "path to $key",
prompt => "Path to $key executable?",
callback => sub { -x },
error => 'Not an executable'
);
}
}
return $self->{$key};
};
for my $exe (@EXES) {
no strict 'refs';
*{$exe} = sub { shift->$find_exe($exe) };
*{"search_$exe\_names"} = sub { @{ shift->{"search_$exe\_names"} } }
}
*executable = \&postgres;
##############################################################################
=head3 bin_dir
my $bin_dir = $pg->bin_dir;
Returns the PostgreSQL binary directory path. App::Info::RDBMS::PostgreSQL
gathers the path from the system call C<`pg_config --bindir`>.
B<Events:>
=over 4
=item info
Executing `pg_config --bindir`
=item error
Cannot find bin directory
=item unknown
Enter a valid PostgreSQL bin directory
=back
=cut
# This code reference is used by bin_dir(), lib_dir(), and so_lib_dir() to
# validate a directory entered by the user.
my $is_dir = sub { -d };
sub bin_dir {
my $self = shift;
return unless $self->{pg_config};
unless (exists $self->{bin_dir} ) {
if (my $dir = $get_data->($self, '--bindir')) {
$self->{bin_dir} = $dir;
} else {
# Handle an unknown value.
$self->error("Cannot find bin directory");
$self->{bin_dir} = $self->unknown( key => 'postgres bin dir',
lib/App/Info/RDBMS/PostgreSQL.pm view on Meta::CPAN
=cut
# Location of dynamically loadable modules.
sub so_lib_dir {
my $self = shift;
return unless $self->{pg_config};
unless (exists $self->{so_lib_dir} ) {
if (my $dir = $get_data->($self, '--pkglibdir')) {
$self->{so_lib_dir} = $dir;
} else {
# Handle an unknown value.
$self->error("Cannot find shared object library directory");
$self->{so_lib_dir} =
$self->unknown( key => 'postgres so directory',
callback => $is_dir)
}
}
return $self->{so_lib_dir};
}
##############################################################################
=head3 configure options
my $configure = $pg->configure;
Returns the options with which the PostgreSQL server was
configured. App::Info::RDBMS::PostgreSQL gathers the configure data from the
system call C<`pg_config --configure`>.
B<Events:>
=over 4
=item info
Executing `pg_config --configure`
=item error
Cannot find configure information
=item unknown
Enter PostgreSQL configuration options
=back
=cut
sub configure {
my $self = shift;
return unless $self->{pg_config};
unless (exists $self->{configure} ) {
if (my $conf = $get_data->($self, '--configure')) {
$self->{configure} = $conf;
} else {
# Configure can be empty, so just make sure it exists and is
# defined. Don't prompt.
$self->{configure} = '';
}
}
return $self->{configure};
}
##############################################################################
=head3 home_url
my $home_url = $pg->home_url;
Returns the PostgreSQL home page URL.
=cut
sub home_url { "http://www.postgresql.org/" }
##############################################################################
=head3 download_url
my $download_url = $pg->download_url;
Returns the PostgreSQL download URL.
=cut
sub download_url { "http://www.postgresql.org/mirrors-ftp.html" }
##############################################################################
=head3 search_exe_names
my @search_exe_names = $app->search_exe_names;
Returns a list of possible names for F<pg_config> executable. By default, only
F<pg_config> is returned (or F<pg_config.exe> on Win32).
Note that this method is not used to search for the PostgreSQL server
executable, only F<pg_config>.
=cut
sub search_exe_names {
my $self = shift;
my $exe = 'pg_config';
$exe .= '.exe' if WIN32;
return ($self->SUPER::search_exe_names, $exe);
}
##############################################################################
=head3 search_bin_dirs
my @search_bin_dirs = $app->search_bin_dirs;
Returns a list of possible directories in which to search an executable. Used
by the C<new()> constructor to find an executable to execute and collect
( run in 1.029 second using v1.01-cache-2.11-cpan-6aa56a78535 )