Slackware::Slackget - Main library for slack-get package manager 1.X

    use Slackware::Slackget;

    my $sgo = Slackware::Slackget->new(
    	-config => '/etc/slack-get/config.xml',
	-name => 'slack-getd',
	-version => '1.0.1228'
    );

	-config => the name of the configuration file.
	-name => ignored : for backward compatibility
	-version => ignored : for backward compatibility

	if ( $sgo->slackware_version >= 12.0.0 ){
		print "Slackware distribution is ok, let's continue.\n";
	}

	# Slackware::Slackget::Plugin::MyPlugin is the name of the plug-in
	# $self is the reference to the current Slackware::Slackget object.

	my $plugin = Slackware::Slackget::Plugin::MyPlugin->new( $self ) ;

	$sgo->load_plugins( ['HOOK_COMMAND_LINE_OPTIONS','HOOK_COMMAND_LINE_HELP','HOOK_START_DAEMON','HOOK_RESTART_DAEMON','HOOK_STOP_DAEMON'], 'daemon');

	$sgo->register_plugins(\@plugins, \@HOOKS) ;

	$sgo->call_plugins( 'HOOK_START_DAEMON' ) ;

	$sgo->base()->compil_package_directory('/var/log/packages/');

	$sgo->pkgtools()->install( $package_list ) ;

	$sgo->pkgtools()->remove(<some package>);

	$sgo->pkgtools()->install(<some package>);

	$sgo->pkgtools()->upgrade(<some package>);

	print $sgo->config()->{common}->{'file-encoding'} ;

	print "Official media is: ",$sgo->get_config_token('/daemon/official-media'),"\n";

	$sgo->set_config_token('/daemon/official-media','slackware-12.0');

	$sgo->auth()->can_connect($client) or die "Client not allowed to connect here\n";

    perldoc Slackware::Slackget

package Slackware::Slackget;

use warnings;
use strict;

require Slackware::Slackget::Base ;
require Slackware::Slackget::Network::Auth ;
require Slackware::Slackget::Config ;
require Slackware::Slackget::PkgTools ;
use Slackware::Slackget::File;

our $VERSION = '0.17';

sub new {
	my $class = 'Slackware::Slackget' ;
	my $self = {} ;
	if(scalar(@_)%2 != 0)
	{
		$class = shift(@_) ;
	}
	my %args = @_ ;
	die "FATAL: You must pass a configuration file as -config parameter.\n" if(!defined($args{'-config'}) || ! -e $args{'-config'}) ;
	$self->{'config'} = new Slackware::Slackget::Config ( $args{'-config'} )  or die "FATAL: error during configuration file parsing\n$!\n" ;
	$self->{'base'} = new Slackware::Slackget::Base ( $self->{'config'} );
	$self->{'pkgtools'} = new Slackware::Slackget::PkgTools ( $self->{'config'} );
	$self->{'auth'} = Slackware::Slackget::Network::Auth->new( $self->{'config'} );
	$self->{'slackware_version'}=undef;
	bless($self,$class) ;
	return $self;
}

sub slackware_version {
	my $self = shift;
	unless( defined($self->{'slackware_version'}) ){
		my $file = Slackware::Slackget::File->new('/etc/slackware-version');
		my $line = $file->get_line(0);
		chomp $line;
		if( $line =~ /^Slackware\s*([\d\.]+)$/ ){
			$self->{'slackware_version'}=$1;
		}
	}
	return $self->{'slackware_version'};
}

sub load_plugins {
	my $self = shift;
	my $HOOKS = shift;
	my $plugin_type = shift; # TODO: impl�enter la s��tion des types de plug-in
	my $extra_ref = shift;
# 	print "[SG10] needed type : $plugin_type\n";
	#NOTE : searching for install plug-in
	$self->log()->Log(2,"searching for plug-in\n") ;
	my %tmp_pg;
	foreach my $dir (@INC)
	{
		if( -e "$dir/Slackware/Slackget/Plugin" && -d "$dir/Slackware/Slackget/Plugin")
		{
			foreach my $name (`ls -1 $dir/Slackware/Slackget/Plugin/*.pm`)
			{
				chomp $name ;
				$name =~ s/.+\/([^\/]+)\.pm$/$1/;
				$self->log()->Log(2,"found plug-in: $name\n") ;
 				print "[SG10] found plug-in: $name in $dir/Slackware/Slackget/Plugin/\n" ;
# 				push @plugins_name, $name;
				$tmp_pg{$name} = 1;
			}
		}
	}
	#NOTE : loading plug-in
	$self->log()->Log(2,"loading plug-in\n") ;
	my @loaded_plugins;
# 	foreach my $plg (@plugins_name)
	foreach my $plg (keys(%tmp_pg))
	{
		my $ret = eval qq{require Slackware::Slackget::Plugin::$plg} ;
		unless($ret)
		{
			if($@)
			{
				warn "Fatal Error while parsing plugin $plg : $@\n";
				$self->log()->Log(1,"Fatal Error while parsing plugin $plg (this is a programming error) : $@\n") ;
			}
			elsif($!)
			{
				warn "Fatal Error while loading plugin $plg : $!\n";
				$self->log()->Log(1,"Fatal Error while parsing plugin $plg : $!\n") ;
			}
		}
		else
		{
			my $package = "Slackware::Slackget::Plugin::$plg";
# 			print "[SG10] \$package:$package\n";
			my $type = '$'.$package.'::PLUGIN_TYPE';
# 			print "[SG10] \$type:$type\n";
			my $pg_type = eval qq{ $type };
			if(defined($pg_type) && ($pg_type eq $plugin_type or $pg_type eq 'ALL'))
			{
				print "[SG10] loaded success for plug-in $plg\n" ;
				$self->log()->Log(3,"loaded success for plug-in $plg\n") ;
				push @loaded_plugins, $plg;
				$self->{'plugin'}->{'types'}->{$ret} = $pg_type ;
			}
		}
	}
	#NOTE : creating new instances
	$self->log()->Log(2,"creating new plug-in instance\n") ;
	my @plugins;
	foreach my $plugin (@loaded_plugins)
	{
		my $package = "Slackware::Slackget::Plugin::$plugin";
		my $ret;
		if($plugin_type=~ /gui/i)
		{
			# TODO: tester le code de chargement d'un plug-in graphique, la ligne suivante n'a pas encore ��test�
			print "[DEBUG Slackware::Slackget.pm::load_plugins()] loading package \"$package\" call is \"use $package; $package( $extra_ref ) ;\" }\"\n";
			$ret = eval "use $package; $package( $extra_ref ) ;" ;
		}
		else
		{
			$ret = eval{ $package->new($self) ; } ;
		}
		
		if($@ or !$ret)
		{
			$self->{'plugin'}->{'types'}->{$ret} = undef;
			delete $self->{'plugin'}->{'types'}->{$ret} ;
			warn "Fatal Error while creating new instance of plugin $package: $@\n";
			$self->log()->Log(1,"Fatal Error while creating new instance of plugin $package: $@\n") ;
		}
		else
		{
			
# 			print "[SG10] $plugin instanciates\n" ;
			$self->log()->Log(3,"$plugin instanciates\n") ;
# 			if($plugin_type=~ /gui/i)
# 			{
# 				$ret->show();
# 			}
			print "[DEBUG Slackware::Slackget.pm::load_plugins()] print pushing reference \"$ret\" on the plugin stack\n";
			push @plugins, $ret;
		}
	}
	%tmp_pg = ();
	@loaded_plugins = ();
	$self->register_plugins(\@plugins,$HOOKS);
}

sub register_plugins
{
	my ($self,$plugins,$HOOKS) = @_ ;
	$self->{'plugin'}->{'raw_table'} = $plugins ;
	$self->{'plugin'}->{'sorted'} = {} ;
	# NOTE: dispatching plug-ins by hooks.
	$self->log()->Log(2,"dispatching plug-in by supported HOOKS\n") ;
	foreach my $hook (@{ $HOOKS })
	{
		my $hk = lc($hook) ;
# 		print "[DEBUG Slackware::Slackget.pm::register_plugins()] examining if plug-in support hook $hk\n";
		$self->{'plugin'}->{'sorted'}->{$hook} = [] ;
		foreach my $plugin (@{ $plugins })
		{
			if($self->{'plugin'}->{'types'}->{$plugin}=~ /gui/i)
			{
				
				eval{ $plugin->$hk('test') ;};
				if($@)
				{
					print "[SG10] plug-in $plugin do not support hook $hook\n" ;
#  					warn "$@\n";
				}
				else
				{
					print "[SG10] registered plug-in $plugin for hook $hook\n" ;
					$self->log()->Log(3,"registered plug-in $plugin for hook $hook\n") ;
					push @{ $self->{'plugin'}->{'sorted'}->{$hook} },$plugin ;
				}
			}
			else
			{
				if($plugin->can($hk))
				{
					print "[SG10] registered plug-in $plugin for hook $hook\n" ;
					$self->log()->Log(3,"registered plug-in $plugin for hook $hook\n") ;
					push @{ $self->{'plugin'}->{'sorted'}->{$hook} },$plugin ;
				}
			}
		}
	}
}

sub call_plugins
{
	my $self = shift;
	my $HOOK = shift ;
	my @returned;
	foreach my $pg ( @{ $self->{'plugin'}->{'sorted'}->{$HOOK} })
	{
		my $callback = lc($HOOK);
		push @returned, eval{ $pg->$callback(@_) ;} ;
		if($@)
		{
			$self->{'log'}->Log(1,"An error occured while attempting to call plug-in ".ref($pg)." for hook $HOOK. The error occured in method $callback. The evaluation return the following error : $@\n");
		}
	}
	return @returned ;
}

sub base
{
	my $self = shift;
	return $self->{'base'} ;
}

sub pkgtools
{
	my $self = shift;
	return $self->{'pkgtools'} ;
}

sub removepkg {
	my ($self,@params) = @_;
	return $self->{'pkgtools'}->remove(@params) ;
}

sub installpkg {
	my ($self,@params) = @_;
	return $self->{'pkgtools'}->install(@params) ;
}

sub upgradepkg {
	my ($self,@params) = @_;
	print "Slackware::slackget::upgradepkg: pass \@params to pkgtools->upgrade(@params).\n";
	return $self->{'pkgtools'}->upgrade(@params) ;
}

sub config
{
	my $self = shift;
	my $cfg_name = shift;
	if($cfg_name)
	{
		return undef if(!defined($cfg_name) || ! -e $cfg_name) ;
		$self->{'config'} = new Slackware::Slackget::Config ( $cfg_name )  or die "FATAL: error during configuration file parsing\n$!\n" ;
		return 1;
	}
	else
	{
		return $self->{'config'} ;
	}
}

sub get_config_token {
	my ($self, $query) = @_;
	return $self->{'config'}->get_token($query);
}

sub set_config_token {
	my ($self, $query,$value) = @_;
	return $self->{'config'}->set_token($query,$value);
}

sub auth
{
	my $self = shift;
	return $self->{'auth'} ;
}

1; # End of Slackware::Slackget