use warnings;
use Sys::Guestfs;
+use File::Temp qw/tempdir/;
+use Locale::TextDomain 'libguestfs';
# Optional:
eval "use Sys::Virt;";
sub open_guest
{
+ local $_;
my $first = shift;
my %params = @_;
} elsif (ref ($first) eq "SCALAR") {
@images = ($first);
} else {
- die "open_guest: first parameter must be a string or an arrayref"
+ die __"open_guest: first parameter must be a string or an arrayref"
}
my ($conn, $dom);
if (-e $images[0]) {
foreach (@images) {
- die "guest image $_ does not exist or is not readable"
+ die __x("guest image {imagename} does not exist or is not readable",
+ imagename => $_)
unless -r $_;
}
} else {
- die "open_guest: no libvirt support (install Sys::Virt, XML::XPath and XML::XPath::XMLParser)"
+ die __"open_guest: no libvirt support (install Sys::Virt, XML::XPath and XML::XPath::XMLParser)"
unless exists $INC{"Sys/Virt.pm"} &&
exists $INC{"XML/XPath.pm"} &&
exists $INC{"XML/XPath/XMLParser.pm"};
- die "open_guest: too many domains listed on command line"
+ die __"open_guest: too many domains listed on command line"
if @images > 1;
$conn = Sys::Virt->new (readonly => 1, @_);
- die "open_guest: cannot connect to libvirt" unless $conn;
+ die __"open_guest: cannot connect to libvirt" unless $conn;
my @doms = $conn->list_defined_domains ();
- my $isitinactive = "an inactive libvirt domain";
+ my $isitinactive = 1;
unless ($readwrite) {
# In the case where we want read-only access to a domain,
# allow the user to specify an active domain too.
push @doms, $conn->list_domains ();
- $isitinactive = "a libvirt domain";
+ $isitinactive = 0;
}
foreach (@doms) {
if ($_->get_name () eq $images[0]) {
last;
}
}
- die "$images[0] is not the name of $isitinactive\n" unless $dom;
+
+ unless ($dom) {
+ if ($isitinactive) {
+ die __x("{imagename} is not the name of an inactive libvirt domain\n",
+ imagename => $images[0]);
+ } else {
+ die __x("{imagename} is not the name of a libvirt domain\n",
+ imagename => $images[0]);
+ }
+ }
# Get the names of the image(s).
my $xml = $dom->get_xml_description ();
my $p = XML::XPath->new (xml => $xml);
my @disks = $p->findnodes ('//devices/disk/source/@dev');
+ push (@disks, $p->findnodes ('//devices/disk/source/@file'));
+
+ die __x("{imagename} seems to have no disk devices\n",
+ imagename => $images[0])
+ unless @disks;
+
@images = map { $_->getData } @disks;
}
my @partitions = $g->list_partitions ();
my @pvs = $g->pvs ();
- @partitions = grep { ! is_pv ($_, @pvs) } @partitions;
+ @partitions = grep { ! _is_pv ($_, @pvs) } @partitions;
my @lvs = $g->lvs ();
return sort (@lvs, @partitions);
}
-sub is_pv {
+sub _is_pv {
local $_;
my $t = shift;
my $path = shift;
if (substr ($path, 0, 1) ne "/") {
- warn "resolve_windows_path: path must start with a / character";
+ warn __"resolve_windows_path: path must start with a / character";
return undef;
}
=item osdistro
(For Linux root partitions only).
-Operating system distribution. One of: "fedora", "redhat",
-"debian".
+Operating system distribution. One of: "fedora", "rhel", "centos",
+"scientific", "debian".
+
+=item package_format
+
+(For Linux root partitions only)
+The package format used by the guest distribution. One of: "rpm", "dpkg".
+
+=item package_management
+
+(For Linux root partitions only)
+The package management tool used by the guest distribution. One of: "rhn",
+"yum", "apt".
=item osversion
if ($g->is_file ("/grub/menu.lst") ||
$g->is_file ("/grub/grub.conf")) {
$r{content} = "linux-grub";
- check_grub ($g, \%r);
+ _check_grub ($g, \%r);
goto OUT;
}
$g->is_file ("/etc/fstab")) {
$r{content} = "linux-root";
$r{is_root} = 1;
- check_linux_root ($g, \%r);
+ _check_linux_root ($g, \%r);
goto OUT;
}
$r{fsos} = "windows";
$r{content} = "windows-root";
$r{is_root} = 1;
- check_windows_root ($g, \%r, $use_windows_registry);
+ _check_windows_root ($g, \%r, $use_windows_registry);
goto OUT;
}
}
return \%r;
}
-sub check_linux_root
+sub _check_linux_root
{
local $_;
my $g = shift;
# Look into /etc to see if we recognise the operating system.
if ($g->is_file ("/etc/redhat-release")) {
+ $r->{package_format} = "rpm";
+
$_ = $g->cat ("/etc/redhat-release");
if (/Fedora release (\d+\.\d+)/) {
$r->{osdistro} = "fedora";
- $r->{osversion} = "$1"
- } elsif (/(Red Hat Enterprise Linux|CentOS|Scientific Linux).*release (\d+).*Update (\d+)/) {
- $r->{osdistro} = "redhat";
- $r->{osversion} = "$2.$3";
- } elsif (/(Red Hat Enterprise Linux|CentOS|Scientific Linux).*release (\d+(?:\.(\d+))?)/) {
- $r->{osdistro} = "redhat";
- $r->{osversion} = "$2";
- } else {
- $r->{osdistro} = "redhat";
+ $r->{osversion} = "$1";
+ $r->{package_management} = "yum";
+ }
+
+ elsif (/(Red Hat Enterprise Linux|CentOS|Scientific Linux)/) {
+ my $distro = $1;
+
+ if($distro eq "Red Hat Enterprise Linux") {
+ $r->{osdistro} = "rhel";
+ }
+
+ elsif($distro eq "CentOS") {
+ $r->{osdistro} = "centos";
+ $r->{package_management} = "yum";
+ }
+
+ elsif($distro eq "Scientific Linux") {
+ $r->{osdistro} = "scientific";
+ $r->{package_management} = "yum";
+ }
+
+ # Shouldn't be possible
+ else { die };
+
+ if (/$distro.*release (\d+).*Update (\d+)/) {
+ $r->{osversion} = "$1.$2";
+ }
+
+ elsif (/$distro.*release (\d+(?:\.(?:\d+))?)/) {
+ $r->{osversion} = "$1";
+ }
+
+ # Package management in RHEL changed in version 5
+ if ($r->{osdistro} eq "rhel") {
+ if ($r->{osversion} >= 5) {
+ $r->{package_management} = "yum";
+ } else {
+ $r->{package_management} = "rhn";
+ }
+ }
+ }
+
+ else {
+ $r->{osdistro} = "redhat-based";
}
} elsif ($g->is_file ("/etc/debian_version")) {
+ $r->{package_format} = "dpkg";
+ $r->{package_management} = "apt";
+
$_ = $g->cat ("/etc/debian_version");
if (/(\d+\.\d+)/) {
$r->{osdistro} = "debian";
# XXX We could parse this better. This won't work if /boot.ini is on
# a different drive from the %systemroot%, and in other unusual cases.
-sub check_windows_root
+sub _check_windows_root
{
local $_;
my $g = shift;
if (defined $systemroot) {
$r->{systemroot} = resolve_windows_path ($g, "/$systemroot");
if (defined $r->{systemroot} && $use_windows_registry) {
- check_windows_registry ($g, $r, $r->{systemroot});
+ _check_windows_registry ($g, $r, $r->{systemroot});
}
}
}
}
-sub check_windows_registry
+sub _check_windows_registry
{
local $_;
my $g = shift;
if (defined $configdir) {
my $softwaredir = resolve_windows_path ($g, "$configdir/software");
if (defined $softwaredir) {
- load_windows_registry ($g, $r, $softwaredir,
- "HKEY_LOCAL_MACHINE\\SOFTWARE");
+ _load_windows_registry ($g, $r, $softwaredir,
+ "HKEY_LOCAL_MACHINE\\SOFTWARE");
}
my $systemdir = resolve_windows_path ($g, "$configdir/system");
if (defined $systemdir) {
- load_windows_registry ($g, $r, $systemdir,
- "HKEY_LOCAL_MACHINE\\System");
+ _load_windows_registry ($g, $r, $systemdir,
+ "HKEY_LOCAL_MACHINE\\System");
}
}
}
-sub load_windows_registry
+sub _load_windows_registry
{
local $_;
my $g = shift;
close SAVEERR;
unless ($res == 0) {
- warn "reged command failed: $?";
+ warn __x("reged command failed: {errormsg}", errormsg => $?);
return;
}
# it.
my $content;
unless (open F, "$dir/out") {
- warn "no output from reged command: $!";
+ warn __x("no output from reged command: {errormsg}", errormsg => $!);
return;
}
{ local $/ = undef; $content = <F>; }
$r->{registry} = \@registry;
}
-sub check_grub
+sub _check_grub
{
local $_;
my $g = shift;
root => $fses->{$_},
root_device => $_
);
- get_os_version ($g, \%r);
- assign_mount_points ($g, $fses, \%r);
+ _get_os_version ($g, \%r);
+ _assign_mount_points ($g, $fses, \%r);
$oses{$_} = \%r;
}
}
return \%oses;
}
-sub get_os_version
+sub _get_os_version
{
local $_;
my $g = shift;
$r->{os} = $r->{root}->{fsos} if exists $r->{root}->{fsos};
$r->{distro} = $r->{root}->{osdistro} if exists $r->{root}->{osdistro};
$r->{version} = $r->{root}->{osversion} if exists $r->{root}->{osversion};
+ $r->{package_format} = $r->{root}->{package_format}
+ if exists $r->{root}->{package_format};
+ $r->{package_management} = $r->{root}->{package_management}
+ if exists $r->{root}->{package_management};
}
-sub assign_mount_points
+sub _assign_mount_points
{
local $_;
my $g = shift;
foreach (@fstab) {
my ($spec, $file) = @$_;
- my ($dev, $fs) = find_filesystem ($g, $fses, $spec);
+ my ($dev, $fs) = _find_filesystem ($g, $fses, $spec);
if ($dev) {
$r->{mounts}->{$file} = $dev;
$r->{filesystems}->{$dev} = $fs;
}
# Find filesystem by device name, LABEL=.. or UUID=..
-sub find_filesystem
+sub _find_filesystem
{
my $g = shift;
my $fses = shift;
return ($_, $fses->{$_});
}
}
- warn "unknown filesystem label $label\n";
+ warn __x("unknown filesystem label {label}\n", label => $label);
return ();
} elsif (/^UUID=(.*)/) {
my $uuid = $1;
return ($_, $fses->{$_});
}
}
- warn "unknown filesystem UUID $uuid\n";
+ warn __x("unknown filesystem UUID {uuid}\n", uuid => $uuid);
return ();
} else {
return ($_, $fses->{$_}) if exists $fses->{$_};
return () if m{/dev/cdrom};
- warn "unknown filesystem $_\n";
+ warn __x("unknown filesystem {fs}\n", fs => $_);
return ();
}
}
my $g = shift;
my $os = shift;
- check_for_applications ($g, $os);
- check_for_kernels ($g, $os);
+ _check_for_applications ($g, $os);
+ _check_for_kernels ($g, $os);
if ($os->{os} eq "linux") {
- check_for_modprobe_aliases ($g, $os);
- check_for_initrd ($g, $os);
+ _check_for_modprobe_aliases ($g, $os);
+ _check_for_initrd ($g, $os);
}
}
-sub check_for_applications
+sub _check_for_applications
{
local $_;
my $g = shift;
my $osn = $os->{os};
if ($osn eq "linux") {
- my $distro = $os->{distro};
- if (defined $distro && ($distro eq "redhat" || $distro eq "fedora")) {
+ my $package_format = $os->{package_format};
+ if (defined $package_format && $package_format eq "rpm") {
my @lines = $g->command_lines
(["rpm",
"-q", "-a",
$os->{apps} = \@apps;
}
-sub check_for_kernels
+sub _check_for_kernels
{
local $_;
my $g = shift;
#
# XXX This doesn't look beyond /etc/modprobe.conf, eg. in /etc/modprobe.d/
-sub check_for_modprobe_aliases
+sub _check_for_modprobe_aliases
{
local $_;
my $g = shift;
for my $path ( @results ) {
$path =~ m{^/files(.*)/alias(?:\[\d*\])?$}
- or die("$path doesn't match augeas pattern");
+ or die __x("{path} doesn't match augeas pattern",
+ path => $path);
my $file = $1;
my $alias;
# Get a listing of device drivers in any initrd corresponding to a
# kernel. This is an indication of what can possibly be booted.
-sub check_for_initrd
+sub _check_for_initrd
{
local $_;
my $g = shift;
my $version = $1;
my @modules;
- eval {
- @modules = $g->initrd_list ("/boot/$initrd");
- };
- unless ($@) {
- @modules = grep { m,([^/]+)\.ko$, || m,([^/]+)\.o$, } @modules;
- $initrd_modules{$version} = \@modules
- } else {
- warn "/boot/$initrd: could not read initrd format"
+ # Disregard old-style compressed ext2 files, since cpio
+ # takes ages to (fail to) process these.
+ if ($g->file ("/boot/$initrd") !~ /gzip compressed/ ||
+ $g->zfile ("gzip", "/boot/$initrd") !~ /ext2 filesystem/) {
+ eval {
+ @modules = $g->initrd_list ("/boot/$initrd");
+ };
+ unless ($@) {
+ @modules = grep { m,([^/]+)\.ko$, || m,([^/]+)\.o$, }
+ @modules;
+ $initrd_modules{$version} = \@modules
+ } else {
+ warn __x("{filename}: could not read initrd format",
+ filename => "/boot/$initrd");
+ }
}
}
}
git.annexia.org / libguestfs.git / blobdiff