PITA::Guest - The PITA Guest abstract, a container for running tests

  $guest = PITA::Guest->new( 'guest-51231.pita' );
  $guest = PITA::Guest->new( \$file_content     );
  $guest = PITA::Guest->new( $guest_xml_object  );

  $response = $guest->test( 'request.pita' );

package PITA::Guest;

use 5.008;
use strict;
use Process        ();
use File::Spec     ();
use File::Basename ();
use Params::Util   qw{ _STRING _SCALAR _INSTANCE };
use PITA::XML      ();

our $VERSION = '0.50';
our @ISA     = 'Process';





#####################################################################
# Constructors

sub new {
	my $class = shift;

	# Handle the param
	my $file      = undef;
	my $guest_xml = undef;
	if ( _INSTANCE($_[0], 'PITA::XML::Guest') ) {
		$guest_xml = shift;

	} elsif ( _STRING($_[0]) ) {
		$file = shift;
		unless ( -f $file ) {
			Carp::croak('Did not provide a valid filename');
		}
		$guest_xml = PITA::XML::Guest->read($file);

	} else {
		Carp::croak("Invalid param provided to PITA::Guest::new");
	}

	# Create the object
	my $self = bless {
		file     => $file,
		guestxml => $guest_xml,
		driver   => undef,
	}, $class;

	# If and only if the Guest has an image, save its absolute path
	if ( $self->guestxml->files ) {
		my $filexml  = ($self->guestxml->files)[0];
		my $filename = $filexml->filename;
		if ( File::Spec->file_name_is_absolute( $filename ) ) {
			$self->{absimage} = $filename;
		} elsif ( defined $file ) {
			$filename = File::Spec->catfile(
				File::Basename::dirname($file),
				$filename,
			);
			unless ( File::Spec->file_name_is_absolute( $filename ) ){
				$filename = File::Spec->rel2abs( $filename );
			}
			$self->{absimage} = $filename;
		} elsif ( defined $guest_xml->base ) {
			$filename = File::Spec->catfile(
				$guest_xml->base,
				$filename,
			);
			unless ( File::Spec->file_name_is_absolute( $filename ) ){
				$filename = File::Spec->rel2abs( $filename );
			}
			$self->{absimage} = $filename;
		} else {
			die "Unable to locate image file for guest";
		}
	}

	# Create the driver
	my $driver = 'PITA::Guest::Driver::' . $self->guestxml->driver;
	eval "require $driver"; die $@ if $@;
	my %params = ( guest => $self->guestxml );
	if ( $self->{absimage} ) {
		$params{absimage} = $self->{absimage};
	}
	if ( $self->{minicpan} ) {
		$params{minicpan} = $self->{minicpan};
	}
	if ( $driver->isa('PITA::Guest::Driver::Image') ) {
		$params{support_server_addr} = '127.0.0.1';
		$params{support_server_port} = 12345;
	}
	$self->{driver} = $driver->new( %params );

	$self;
}





#####################################################################
# Accessors

sub file {
	$_[0]->{file};
}

sub guestxml {
	$_[0]->{guestxml};
}

sub discovered {
	$_[0]->guestxml->discovered;
}

sub driver {
	$_[0]->{driver};
}





#####################################################################
# Main Methods

sub ping {
	$_[0]->driver->ping;
}

sub discover {
	$_[0]->driver->discover;
}

sub test {
	my $self     = shift;
	my $filename = _STRING(shift);
	unless ( $filename and -f $filename and -r _ ) {
		Carp::croak('Did not provide a request file');
	}

	# Load the request object
	my $request = PITA::XML::Request->read($filename);
	unless ( $request ) {
		Carp::croak('Failed to load request file');
	}

	# Locate the archive file, converting the request
	# filename to absolute if needed.
	### FIXME: If the <filename> tag can contain anything
	###        other than a raw filename, this code is not
	###        portable, and needs improving to split the
	###        <filename> first before appending.
	my $archive = File::Basename::dirname($filename);
	$archive = File::Spec->catfile( $archive, $request->file->filename );
	unless ( $archive and -f $archive and -r _ ) {
		Carp::croak('Failed to find archive, or insufficient permissions');
	}
	unless ( File::Spec->file_name_is_absolute( $archive ) ) {
		$archive = File::Spec->rel2abs( $archive );
	}
	$request->file->{filename} = $archive;

	# Just use the first platform until we write a selection method
	my $platform = ($self->guestxml->platforms)[0];
	unless ( _INSTANCE($platform, 'PITA::XML::Platform') ) {
		Carp::croak('Could not autoselect a platform');
	}

	# Hand off the testing request to the driver
	$self->driver->test( $request, $platform );
}

sub save {
	my $self = shift;
	unless ( defined $self->file ) {
		Carp::croak("No file to save to");
	}
	$self->guestxml->write( $self->file );
}

1;