#!/usr/bin/perl -w
#
=head1 NAME

cbusterize - Creates the correct CasparBuster structure in your CMS environment

=head1 SYNOPSIS

cbusterize [options] --source /path/to/file/to/CasparBusterize

 Options:
   --debug  |-d			debug mode
   --help   |-h			brief help message
   --man			full documentation
   --force   |-f			force copy of files, even if they exist
   --source |-s <file/dir>	directory or files to copy in the CasparBuster tree (',' separated if many)
   --plugin |-p <plugin name>	plugin defining what to copy in the CasparBuster tree (',' separated if many)
   --machine|-m <machine>	machine to consider in the subtree

=head1 OPTIONS

=over 4

=item B<--debug>

Enter debug mode. This will print what would be done. No commands are executed,
so this is safe to use when testing.

=item B<--help>

Print a brief help message and exits.

=item B<--man>

Prints the manual page and exits.

=item B<--machine> I<machine name>

Specify the machine to consider when dealing with the CasparBuster structure. 
The file will be taken from this machine, and a subdirectory named after the machine 
will be used under the basedir to host the directory structure to manage

=item B<--source> I<path>

Specify the path to the source file or directory to manage with CasparBuster. Multiple paths can be specified separated by ','.

=item B<--plugin> I<name>

Specify the name of the plugin to manage with CasparBuster. Multiple plugins can be specified separated by ','.
A plugin defines a set of files (with their mode and owner), a set of directories (with their mode and owner) and a set of scripts to launch once the files are copied remotely.

=back

=head1 DESCRIPTION

Creates a directory under the machine dir passed as parameter in working 
directory or directory passed as parameter named like the last path
element of the parameter, and creates the standard CasparBuster setup 
that refers to the parameter path in the new directory, and configuration 
files when possible. It also copies the original config file into the new dir.
Is reasonably picky about path names, tries to avoid common errors.

Schema looks like:

Base dir
   |
   |- machine1 (optional)
   |     |
   |     |-- conf dir1
   |     |       |
   |     |       |- conf file 1
   |   [...]    [...]
   | 
   |- machine2 (optional)
   |     |
   |     |-- conf dir2
   |     |       |
   |     |       |- conf file 2
   |   [...]    [...]

Use of machines require use of option -m (if using cbusemachines in cb.conf)
If not, the conf dirs are directly attached to the base dir

=head1 EXAMPLES

	# this will create the appropriate CasparBuster environment
	# under the base ~/prj/musique-ancienne.org directory (Cf cbbasedir in cb.conf)
	# containing the directory victoria2 for this machine
	# under which it will copy the required structure if needed (/etc/ssh)
	# to finaly put a copy of the file sshd_conf in it from the victoria2 machine

	cbusterize -m victoria2 -s /etc/ssh/sshd_config

=head1 AUTHOR

=over 4

Bruno Cornec, http://brunocornec.wordpress.com

=back

=head1 LICENSE

Copyright (C) 2012  Bruno Cornec <bruno@project-builder.org>
Released under the GPLv2 or the Artistic license at your will.

=cut
use strict;
use CasparBuster::Version;
use CasparBuster::Env;
use CasparBuster::Plugin;
use File::Basename;
use File::Path;
use Getopt::Long;
use Pod::Usage;
use Data::Dumper;
use Net::SSH2;
use ProjectBuilder::Base;
use ProjectBuilder::Conf;
use ProjectBuilder::VCS;

# settings
my $debug = 0;
my $help = undef;
my $man = undef;
my $source = undef;
my $machine = undef;
my $plugin = undef;
my $quiet = undef;
my $force = undef;
my $log = undef;
my $LOG = undef;

my ($cbver,$cbrev) = cb_version_init();
my $appname = "cb";
$ENV{'PBPROJ'} = $appname;
pb_temp_init();

# Initialize the syntax string
pb_syntax_init("$appname (aka CasparBuster) Version $cbver-$cbrev\n");

# parse command-line options
GetOptions(
	'machine|m=s' => \$machine,
	'debug|d+'    => \$debug,
	'help|h'      => \$help,
	'quiet|q'     => \$quiet,
	'force|f'     => \$force,
	'man'         => \$man,
	'logfile|l=s' => \$log,
	'source|s=s'  => \$source,
	'plugin|p=s'  => \$plugin,
) || pb_syntax(-1,0);

if (defined $help) {
	pb_syntax(0,1);
}
if (defined $man) {
	pb_syntax(0,2);
}
if (defined $quiet) {
	$debug=-1;
}
if (defined $log) {
	open(LOG,"> $log") || die "Unable to log to $log: $!";
	$LOG = \*LOG;
	$debug = 0  if ($debug == -1);
}

$pbdebug = $debug;
pb_log_init($debug, $LOG);
pb_log(0,"Starting cbusterize\n");

# Get conf file in context
pb_conf_init($appname);
# The personal one if there is such
pb_conf_add("$ENV{'HOME'}/.cbrc") if (-f "$ENV{'HOME'}/.cbrc");
# The system one
pb_conf_add(cb_env_conffile());

# Get configuration parameters
my %cb;
my $cb = \%cb;
($cb->{'basedir'},$cb->{'usemachines'},$cb->{'cms'}) = pb_conf_get("cbbasedir","cbusemachines","cbcms");
pb_log(2,"%cb: ",Dumper($cb));

# Check for mandatory params
pod2usage("Error: --source or --plugin is a mandatory argument\n") if ((not defined $source) && (not defined $plugin));
pod2usage("Error: --machine is a mandatory argument when configure with cbusemachines = true\n") if (($cb->{'usemachines'}->{$appname} =~ /true/) && (not defined $machine));

if (defined $plugin) {
	# Load plugins
	cb_plugin_load();
}

my $basedir = $cb->{'basedir'}->{$appname};
eval { $basedir =~ s/(\$ENV.+\})/$1/eeg };

pb_log(1, "DEBUG MODE, not doing anything, just printing\nDEBUG: basedir = $basedir\n");
pb_log(1, "DEBUG: source = $source\n") if (defined $source);
pb_log(1, "DEBUG: machine = $machine\n") if (defined $machine);

# Use potentially a remote account if defined
my $account = undef;
my $remote = undef;
($account) = pb_conf_get_if("cbaccount") if (defined $machine);
$remote = $account->{$machine} if ((defined $account) && (defined $machine) && (defined $account->{$machine}));
pb_log(1, "DEBUG: remote account1 = $remote\n") if (defined $remote);
$remote = getpwuid($<) if (not defined $remote);
pb_log(1, "DEBUG: remote account2 = $remote\n");

# Create basedir if it doesn't exist
if (not -d $basedir) {
	if ($debug) {
		pb_log(1, "DEBUG: Creating recursively directory $basedir\n");
	} else {
		pb_mkdir_p($basedir) || die "Unable to recursively create $basedir: $!";
	}
}

if (defined $source) {
	foreach my $f (split(/,/,$source)) {	
		cb_busterize($f,"true");
	}
}

# Now handle plugins if any
my $cbp = ();

if (defined $plugin) {
	foreach my $p (split(/,/,$plugin)) {	
		pb_log(1,"Getting context for plugin $p\n");
		$cbp = cb_plugin_get($p,$cbp);
		pb_log(2,"cbp: ".Dumper($cbp)."\n");
		foreach my $k (keys %{$cbp->{$plugin}->{'dirsandfiles'}}) {
			cb_busterize($k,"true");
		}
		foreach my $k ((keys %{$cbp->{$plugin}->{'dirs'}}),(keys %{$cbp->{$plugin}->{'files'}})) {
			cb_busterize($k,"false");
		}
	}
}

sub cb_busterize {

my $source = shift;
my $recur = shift;

pb_log(2,"Entering cb_busterize source: $source\n");
# Is the source a file or a dir ? Split the source parameter in 2
my $srcdir = undef;
my $srcfile = undef;
my $cmd = undef;
my $ssh2;
my $sftp;

if (not defined $machine) {
	if (-d $source) {
		$srcdir = $source;
	} else {
		$srcdir = dirname($source);
		$srcfile = basename($source);
	}
} else {
	$ssh2 = Net::SSH2->new();
	$ssh2->connect($machine);
	my $hdir = (getpwnam(getpwuid($<)))[7];
	if ($ssh2->auth_publickey($remote,"$hdir/.ssh/id_dsa.pub","$hdir/.ssh/id_dsa")) {
		$sftp = $ssh2->sftp;
		my %dirs = $sftp->stat("$source/.");
		my $res = 0;
		$res = -1 if (not defined $dirs{'mode'});
		pb_log(2,"DEBUG: Found res = $res\n");
		if ($res == 0) {
			$srcdir = $source;
			pb_log(1,"DEBUG: Found remote dir = $source\n");
		} else {
			$srcdir = dirname($source);
			$srcfile = basename($source);
			pb_log(1,"DEBUG: Found remote file = $source\n");
		}
	}
}

pb_log(1,"DEBUG: Found srcdir = $srcdir\n");
if (defined $srcfile) {
	pb_log(1,"DEBUG: Found srcfile = $srcfile\n");
} else {
	pb_log(1,"DEBUG: Found no srcfile\n");
}

# Deduce the target directory from the local structure and the source
my $target = $basedir;
$target .= "/$machine" if defined ($machine);
$target .= "$srcdir";

my $scheme = $cb->{'cms'}->{$appname};

# If both source and target are dirs, then copy into the parent of the target
$target = basename($target) if ((not defined $srcfile) && (-d $target));

# Create target if it doesn't exist
if (not -d $target) {
	if ($debug) {
		pb_log(1,"DEBUG: Creating recursively directory $target\n");
	} else {
		pb_mkdir_p($target) || die "Unable to recursively create $target: $!";
	}
	# Add all the dirs in it to VCS (in reverse order)
	my $tdir = $target;
	my @tab = ();
	while ($tdir ne $basedir) {
		push(@tab,$tdir);
		$tdir = dirname($tdir);
		pb_log(3,"tdir is now $tdir\n");
	}
	if ($debug) {
		pb_log(0,"INFO: Added to your $scheme system the dirs: ".join(' ',reverse(@tab))."\n");
	} else {
		pb_vcs_add($scheme,reverse(@tab));
	}
}

# We need to know where to get the content from
my $cmdopt = "";

# Recursive if we copy dirs
$cmdopt = "-r" if (not defined $srcfile);

if (defined $machine) {
	# TODO replace by $chan->exec + sudo + cat to avoid root access issues
	$cmd = "scp -p -q $cmdopt $remote\@$machine:\'$source\' $target";
} else {
	$cmd = "cp -p $cmdopt $source $target";
}

# Now add content if not already there
if (defined $srcfile) {
	# File case
	if ((! -f "$target/$srcfile") || (defined $force)) {
		if ($debug) {
			pb_log(1,"DEBUG: launching $cmd\n");
		} else {
			pb_system($cmd);
			pb_vcs_add($scheme,"$target/$srcfile");
			pb_log(0,"INFO: Created $target/$srcfile and added it to your $scheme system\n");
		}
	} else {
		pb_log(0,"INFO: File $target/$srcfile already there\n");
	}
} else {
	# Directory case
	if ($debug) {
		if ($recur eq "true") {
			pb_log(1,"DEBUG: launching $cmd\n");
		} else {
			pb_log(1,"DEBUG: mkdir -p $target\n");
		}
	} else {
		if ($recur eq "true") {
			pb_system($cmd);
		}
		pb_vcs_add($scheme,"$target");
		pb_log(0,"INFO: Created $target and added it to your $scheme system\n");
	}
}
$ssh2->disconnect() if (defined $machine);
pb_log(2,"Exiting cb_busterize\n");
}