:
eval 'exec perl -wS $0 ${1+"$@"}'
    if 0;
#*************************************************************************
#
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# Copyright 2008 by Sun Microsystems, Inc.
#
# OpenOffice.org - a multi-platform office productivity suite
#
# $RCSfile: cwsresync.pl,v $
#
# $Revision: 1.36 $
#
# This file is part of OpenOffice.org.
#
# OpenOffice.org is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License version 3
# only, as published by the Free Software Foundation.
#
# OpenOffice.org is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Lesser General Public License version 3 for more details
# (a copy is included in the LICENSE file that accompanied this code).
#
# You should have received a copy of the GNU Lesser General Public License
# version 3 along with OpenOffice.org.  If not, see
# <http://www.openoffice.org/license.html>
# for a copy of the LGPLv3 License.
#
#*************************************************************************
#
# cwsresync.pl - sync child workspace modules/files with newer
#                milestones of master workspace
#

use strict;
use Cwd;
use File::Basename;
use File::Copy;
use File::Find;
use File::Glob;
use File::Path;
use Getopt::Long qw(:config no_ignore_case);
use IO::Handle;
use IO::File;
use Carp;

#### module lookup
my @lib_dirs;
BEGIN {
    if ( !defined($ENV{SOLARENV}) ) {
        die "No environment found (environment variable SOLARENV is undefined)";
    }
    push(@lib_dirs, "$ENV{SOLARENV}/bin/modules");
    push(@lib_dirs, "$ENV{SOLARENV}/bin/modules/PCVSLib/lib");
    push(@lib_dirs, "$ENV{COMMON_ENV_TOOLS}/modules") if defined($ENV{COMMON_ENV_TOOLS});
}
use lib (@lib_dirs);

use Cws;

eval {
    require EnvHelper; import EnvHelper;
    require CopyPrj; import CopyPrj;
};
use Cvs;
use GenInfoParser;
use CwsConfig;
use CwsCvsOps;
use CvsModule; # to be removed ASAP
my $config = CwsConfig->get_config();
my $sointernal = $config->sointernal();

#### script id #####

( my $script_name = $0 ) =~ s/^.*\b(\w+)\.pl$/$1/;

my $script_rev;
my $id_str = ' $Revision: 1.36 $ ';
$id_str =~ /Revision:\s+(\S+)\s+\$/
  ? ($script_rev = $1) : ($script_rev = "-");

print "$script_name -- version: $script_rev\n";

#### hardcoded globals #####

my @xtra_files = ( "*.mk", "*.flg", "libCrun*", "libCstd*", "libgcc*", "libstdc*" );
my $platform_resynced_flag = ".cwsresync_complete";

# ignore these files silently during resync
my %resync_silent_ignore_files = ( 'wntmsci3' => 1,
                                   'wntmsci7' => 1,
                                   'wntmsci8' => 1 );

# ignore these files silently during resync
my %resync_always_move_tags = ( 'wntmsci10' => 1 );

# modules to be obligatory copied to each cws
my %obligatory_modules = (  'solenv' => 1,
                            'default_images' => 1,
                            'custom_images' => 1,
                            'ooo_custom_images' => 1,
                            'external_images' => 1,
                            'postprocess' => 1,
                            'instset_native' => 1,
                            'instsetoo_native' => 1,
                            'smoketest_native' => 1,
                            'smoketestoo_native' => 1);

#### global #####

my $opt_debug            = 0;    # misc traces for debugging purposes
my $opt_commit           = 0;    # commit changes
my $opt_merge            = 0;    # merge from MWS into CWS
my $opt_link             = 0;    # relink modules, update solver
my $opt_remove_trees     = 0;    # remove output trees & solver (OO option)
my $opt_complete_modules = 0;    # checkout complete modules for merge ops
my @args_bak = @ARGV;            # store the @ARGS here for logging

my @problem_log = ();

my $umask = umask();
if ( !defined($umask) ) {
    $umask = 22;
}
my $opt_force_checkout = '';
my $opt_skip_update = 0;

# some overall stats
my %global_stats = ('new'       => 0,
                    'removed'   => 0,
                    'merged'    => 0,
                    'moved'     => 0,
                    'anchor'    => 0,
                    'conflict'  => 0,
                    'alert'     => 0,
                    'ignored'   => 0
                   );

#### main #####

my ($dir, $milestone, @args) = parse_options();
my $cws = get_and_verify_cws();
if ( $milestone ) {
    verify_milestone_or_exit($cws, $milestone);
}
my @action_list = parse_args($cws, $dir, $milestone, @args);
walk_action_list($cws, $dir, $milestone, @action_list);
print_plog();
log_stats();
exit(0);

#### subroutines ####

sub log_stats
 {
    my $statistic_log_message;
    $statistic_log_message = "success : ";
    $statistic_log_message .= "merge mode : " if $opt_merge;
    $statistic_log_message .= "commit mode : " if $opt_commit;
    $statistic_log_message .= "link mode : " if $opt_link;
    $statistic_log_message .= "remove output trees mode : " if $opt_remove_trees;
    $statistic_log_message .= "new: $global_stats{'new'} " if $global_stats{'new'};
    $statistic_log_message .= "removed: $global_stats{'removed'} " if $global_stats{'removed'};
    $statistic_log_message .= "merged: $global_stats{'merged'} " if $global_stats{'merged'};
    $statistic_log_message .= "moved: $global_stats{'moved'} " if $global_stats{'moved'};
    $statistic_log_message .= "anchor: $global_stats{'anchor'} " if $global_stats{'anchor'};
    $statistic_log_message .= "conflicts: $global_stats{'conflict'} " if $global_stats{'conflict'};
    $statistic_log_message .= "alerts: $global_stats{'alert'} " if $global_stats{'alert'};
    $statistic_log_message .= "ignored: $global_stats{'ignored'} " if $global_stats{'ignored'};
}   ##create_log_stats

# Get child workspace from environment.
sub get_and_verify_cws
{
    my $childws  = $ENV{CWS_WORK_STAMP};
    my $masterws = $ENV{WORK_STAMP};

    if ( !defined($childws) || !defined($masterws) ) {
        print_error("Can't determine child workspace environment.\n"
                    . "Please initialize environment with setsolar ...", 1);
    }

    my $cws = Cws->new();
    $cws->child($childws);
    $cws->master($masterws);

    # check if we got a valid child workspace
    my $id = $cws->eis_id();
    print "Master: $masterws, Child: $childws, $id\n" if $opt_debug;
    if ( !$id ) {
        print_error("Child workspace $childws for master workspace $masterws not found in EIS database.", 2);
    }
    return $cws;
}

# Parse options and do some sanity checks;
sub parse_options
{   my $dir  = 0;
    my $help = 0;
    my $success = GetOptions('h' => \$help, 'd=s' => \$dir, 'debug' => \$opt_debug,
                             'm=s' => \$opt_merge, 'c' => \$opt_commit, 'l=s' => \$opt_link,
                             'a' => \$opt_force_checkout, 'r' => \$opt_remove_trees,
                             'f' => \$opt_skip_update, 'F' => \$opt_complete_modules );
    if ( !$success || $help ) {
        usage();
        exit(1);
    }

    # some sanity checks
    if ( !($opt_merge || $opt_commit || $opt_link || $opt_remove_trees) ) {
        print_error("Please specify one of '-m', '-c', '-l'.", 0) if ($sointernal);
        print_error("Please specify one of '-m', '-c', '-l', '-r'.", 0) if !($sointernal);
        usage();
        exit(1);
    }

    if ( ($opt_merge || $opt_commit) && !@ARGV ) {
        usage();
        exit(1);
    }

    my $milestone = $opt_merge || $opt_link;
    if ( ($opt_merge && $opt_commit) ||
         ($opt_merge && $opt_link)   ||
         ($opt_commit && $opt_link) )
    {
        print_error("The options '-m milestone', '-c', '-l milestone' are mutally exclusive.", 0);
        usage();
        exit(1);
    }

    if ( $opt_link && $dir ) {
        print_error("The options '-l milestone' and '-d' are mutally exclusive.", 0);
        usage();
        exit(1);
    }

    if ( $milestone eq 'HEAD' && $opt_link ) {
        print_error("'HEAD' is not a valid milestone for '-l milestone' option.", 0);
        usage();
        exit(1);
    }

    if ( $opt_complete_modules && !$opt_merge ) {
        print_error("option '-F' requires merge step (option '-m milestone' must be set).", 0);
        usage();
        exit(1);
    }
    $dir = $dir ? $dir : cwd();

    # check directory
    if ( ! -d $dir ) {
        print_error("'$dir' is not a directory.", 1);
    }
    if ( ! -w $dir ) {
        print_error("Can't write to directory '$dir'.", 1);
    }

    return ($dir, $milestone, @ARGV);
}

# Parse and verify args. Check that all necessary preconditions are fulfilled
# and fill the action_list
sub parse_args
{
    my $cws       = shift;
    my $dir       = shift;
    my $milestone = shift;
    my @args = @_;

    # For each entry in the args list we'll prepare a corresponding entry
    # in the action list. An arg may be a module, a dir in a cvs module
    # or a file in a cvs module. With each arg is an action associated,
    # this may be 'resync_module_action', 'resync_dir_action', 'resync_file_action',
    # 'commit_dir_action', 'commit_file_action' or 'relink_cws_action' depending on the
    # type of the arg and the operation mode

    # The action list has the following format
    # $action_list [$i] = [$arg, $action]
    my @action_list = ();

    # The 'merge' and 'commit' modes share quite a bit of logic. The 'link' mode
    # is completely independent

    if ( (@args > 0) && ($opt_link || $opt_remove_trees)) {
        print_error("Invalid argument.", 0);
        usage();
        exit(1);
    }
    if ( $opt_link ) {
        push(@action_list, [undef, 'relink_cws_action']);
    } elsif ($opt_remove_trees) {
        push(@action_list, [undef, 'remove_output_trees']);
    }
    else {
        # Sanity check
        if ( @args > 1) {
            foreach (@args) {
                if ($_ eq 'all') {
                    print_error("either specify 'all' or a list of modules/files.", 1);
                }
            }
        }

        # If HEAD is specified as milestone, make sure that every argument is really a file.
        if ( $milestone eq 'HEAD' ) {
            foreach ( @args ) {
                if ( ! -f $_ ) {
                    print_error("Only files are allowed as argument for resyncing against HEAD", 0);
                    print_error("'$_' is not a file: $!", 1);
                }
            }
        }

        if ( is_in_module($dir) ) {
            # check arguments for inside module operation
            check_or_exit($cws, $dir, @args);
            foreach my $arg (@args) {
                if ( -f $arg ) {
                    my $action = $opt_commit ? 'commit_file_action' : 'resync_file_action';
                    push(@action_list, [$arg, $action]);
                }
                else {
                    my $action = $opt_commit ? 'commit_dir_action' : 'resync_dir_action';
                    push(@action_list, [$arg, $action]);
                }
            }
        }
        else {
            my @modules = expand_and_verify_modules($cws, @args);
            # check arguments for modules level operation
            if ( is_scratch_dir($dir) ) {
                my $action = $opt_commit ? 'commit_dir_action' : 'resync_module_action';
                foreach (@modules) {
                    push(@action_list, [$_, $action]);
                }
            }
            else {
                check_or_exit($cws, $dir, @modules);
                my $action = $opt_commit ? 'commit_dir_action' : 'resync_dir_action';
                foreach (@modules) {
                    push(@action_list, [$_, $action]);
                }
            }
        }
    }

    return @action_list;
}

# Check if all arguments are physically present on the disk
# either as files or directories
sub check_or_exit
{
    my $cws  = shift;
    my $dir  = shift;
    my @args = @_;

    my $error;

    foreach my $arg (@args) {
        if ( ! -e "$dir/$arg" ) {
            print_error("Can't find '$dir/$arg': $!", 0);
            $error++;
        }
    }
    if ( $error ) {
        print_error("Please run '$script_name -m' either in an empty scratch directory,", 0);
        print_error("or in a directory containing all specified modules,", 0);
        print_error("or, if inside a module,", 0);
        print_error("make certain that all specified files/directories exist.", 2);
    }

    return;
}

# Check if we operate inside a module.
sub is_in_module
{
    my $dir = shift;
    return -d "$dir/CVS" ? 1 : 0;
}

# Check if directory contains modules
sub is_modules_level
{
    my $dir = shift;

    return 0 if is_in_module($dir);

    my @cvsdirs = glob("$dir/*/CVS");
    return @cvsdirs ? 1 : 0;
}

# Check if directory is a scratch directory
sub is_scratch_dir
{
    my $dir = shift;
    return (is_in_module($dir) || is_modules_level($dir)) ? 0 : 1;
}

# Check if requested modules are registered with child workspace.
sub expand_and_verify_modules
{
    my $cws     = shift;
    my @modules = @_;

    my @registered_modules = $cws->modules();
    my $child = $cws->child();

    # call with empty modules list
    return @registered_modules if $modules[0] eq 'all';

    # create hash for easier searching
    my %registered_modules_hash = ();
    for (@registered_modules) {
        $registered_modules_hash{$_}++;
    }

    foreach (@modules) {
        if ( !exists $registered_modules_hash{$_} ) {
            print_error("Module '$_' is not registered for child '$child'.", 2);
        }
    }
    return @modules;
}

# Process the action list
sub walk_action_list
{
    my $cws                 = shift;
    my $dir                 = shift;
    my $qualified_milestone = shift;
    my @action_list         = @_;

    foreach my $entry_ref (@action_list) {
        no strict; # disable strict refs for the next call
        &{$entry_ref->[1]}($cws, $dir, $qualified_milestone, $entry_ref->[0]);
    }

    if ( !$opt_link ) {
        # emit some stats
        print_message(" ========== Totals: ==========") if scalar(%global_stats);
        print_message("New file(s)        : $global_stats{'new'}") if $global_stats{'new'};
        print_message("Remove file(s)     : $global_stats{'removed'}") if $global_stats{'removed'};
        print_message("Merge file(s)      : $global_stats{'merged'}") if $global_stats{'merged'};
        print_message("Conflict(s)        : $global_stats{'conflict'}") if $global_stats{'conflict'};
        print_message("Move branch tag(s) : $global_stats{'moved'}") if $global_stats{'moved'};
        print_message("Move anchor(s)     : $global_stats{'anchor'}") if $global_stats{'anchor'};
        print_message("Alert(s)           : $global_stats{'alert'}") if $global_stats{'alert'};
        print_message("Ignored            : $global_stats{'ignored'}") if $global_stats{'ignored'};
    }
    return;
}

# Merge a whole module in scratch space.
sub resync_module_action
{
    my $cws                 = shift;
    my $dir                 = shift;
    my $qualified_milestone = shift;
    my $module              = shift;

    print_message("");
    print_message(" ========== Merging '$module' ==========");
    print_message("");

    my ($master_branch_tag, $cws_branch_tag, $cws_anchor_tag) = $cws->get_tags();
    my $milestone_tag = get_milestone_tag($cws, $qualified_milestone);
    my $cvs_handle = get_cvs_handle($cws, 'config', $module);
    if ( !defined($cvs_handle) ) {
        print_warning("Skipping '$module' ...");
        print_warning("This might happen if '$module' is obsolete.");
        return;
    }
    print_message("Retrieving changes for '$module' ...");
    my $changes_ref = $cvs_handle->get_changed_files($module, $cws_anchor_tag, $milestone_tag);

    my @files_to_checkout;
    foreach (@{$changes_ref}) {
        push(@files_to_checkout, $_->[0]);
    }

    my $nfiles_to_checkout = @files_to_checkout;
    if ( $opt_complete_modules ) {
        print_message("Check out module '$module' ...");
        $cvs_handle->checkout($dir, $module, undef, $cws_branch_tag);
    }
    elsif ( $nfiles_to_checkout > 0 ) {
        print_message("Check out $nfiles_to_checkout file(s) from module '$module' ...");
        $cvs_handle->checkout($dir, $module, \@files_to_checkout, $cws_branch_tag);
    }
    else {
        print_message("nothing to do for module '$module'");
        # still create a directory even if nothing is to be done, for the benefit of the
        # commit operation
        if ( !mkdir("$dir/$module") ) {
            print_error("Can't mkdir() '$dir/$module': $!", 6);
        }
        if ( !open(README, ">$dir/$module/readme") ) {
            print_error("can't open file '$dir/$module/readme': $!", 7);
        }
        print README "Nothing to be resynced here\n";
        close(README);
        return;
    }

    my $save_dir = cwd();
    # chdir into module
    if ( !chdir("$dir/$module") ) {
        print_error("Can't chdir() to '$dir/$module': $!", 6);
    }

    my $stats_ref = merge_files($cws_anchor_tag, $milestone_tag, $changes_ref, $cvs_handle, $module);

    # chdir back
    chdir($save_dir);

    $global_stats{'new'} += $stats_ref->{'new'};
    $global_stats{'removed'} += $stats_ref->{'removed'};
    $global_stats{'merged'} += $stats_ref->{'merged'};
    $global_stats{'moved'} += $stats_ref->{'moved'};
    $global_stats{'anchor'} += $stats_ref->{'anchor'};
    $global_stats{'conflict'} += $stats_ref->{'conflict'};
    $global_stats{'alert'} += $stats_ref->{'alert'};
    $global_stats{'ignored'} += $stats_ref->{'ignored'};
    print_message(" ---------- '$module' stats:-----------") if scalar(%{$stats_ref});
    print_message("New file(s)    : $stats_ref->{'new'}") if $stats_ref->{'new'};
    print_message("Remove file(s) : $stats_ref->{'removed'}") if $stats_ref->{'removed'};
    print_message("Merge file(s)  : $stats_ref->{'merged'}") if $stats_ref->{'merged'};
    print_message("Conflict(s)    : $stats_ref->{'conflict'}") if $stats_ref->{'conflict'};
    print_message("Move tag(s)    : $stats_ref->{'moved'}") if $stats_ref->{'moved'};
    print_message("Move anchor(s) : $stats_ref->{'anchor'}") if $stats_ref->{'anchor'};
    print_message("Alert(s)       : $stats_ref->{'alert'}") if $stats_ref->{'alert'};
    print_message("Ignored file(s): $stats_ref->{'ignored'}") if $stats_ref->{'ignored'};
    return;
}

# resync_dir_action: not possible
sub resync_dir_action
{
    my $cws                 = shift;
    my $dir                 = shift;
    my $qualified_milestone = shift;
    my $cvs_dir             = shift;

    print_error("Resyncing directories is not possible.", 0);
    print_error("Please resync either complete modules in a scratch", 0);
    print_error("directory or resync a list of files,", 99);

    return;
}

sub resync_file_action
{
    my $cws                 = shift;
    my $dir                 = shift;  # unused, remove me
    my $qualified_milestone = shift;
    my $file                = shift;

    if ( exists $resync_silent_ignore_files{basename($file)} ) {
        print_error("Can't resync special file '$file'!", 33);
    }

    my ($master_branch_tag, $cws_branch_tag, $cws_anchor_tag) = $cws->get_tags();
    my $milestone_tag;
    if ( $qualified_milestone eq 'HEAD' ) {
        $milestone_tag = $master_branch_tag ? $master_branch_tag : 'HEAD';
    }
    else {
        $milestone_tag = get_milestone_tag($cws, $qualified_milestone);
    }

    my $directory = dirname($file);
    my $cvs_handle = get_cvs_handle($cws, 'directory', $directory);
    if ( !defined($cvs_handle) ) {
        print_message("resync_file_action(): can't get cvs_handle");
    }

    my $rep = $cvs_handle->get_relative_path($directory);

    print_message("Retrieving changes for '$file' ...");
    my $changes_ref = $cvs_handle->get_changed_files("$rep/$file", $cws_anchor_tag, $milestone_tag);

    if ( !@{$changes_ref} ) {
        print_warning("'$file' already on resync level '$milestone_tag'\n");
        exit(0);
    }

    # changes_ref contains the path to the file relative to the module (including module prefix)
    # replace with local path
    $changes_ref->[0]->[0] = $file;

    my $stats_ref = merge_files($cws_anchor_tag, $milestone_tag, $changes_ref, $cvs_handle, '');

    $global_stats{'new'} += $stats_ref->{'new'};
    $global_stats{'removed'} += $stats_ref->{'removed'};
    $global_stats{'merged'} += $stats_ref->{'merged'};
    $global_stats{'moved'} += $stats_ref->{'moved'};
    $global_stats{'anchor'} += $stats_ref->{'anchor'};
    print_message("New file(s): $stats_ref->{'new'}") if $stats_ref->{'new'};
    print_message("Removed file(s): $stats_ref->{'removed'}") if $stats_ref->{'removed'};
    print_message("Commit file(s): $stats_ref->{'merged'}") if $stats_ref->{'merged'};
    print_message("Move branch tag(s): $stats_ref->{'moved'}") if $stats_ref->{'moved'};
    print_message("Move anchor tags(s): $stats_ref->{'anchor'}") if $stats_ref->{'anchor'};
    return;
}

sub commit_dir_action
{
    my $cws                 = shift;
    my $dir                 = shift;
    my $qualified_milestone = shift; # unused and not initialized
    my $cvs_dir             = shift;

    print_message("========== Commit changes to '$cvs_dir': ==========");

    my $save_dir = cwd();

    # chdir into module
    if ( !chdir("$dir/$cvs_dir") ) {
        print_warning("Can't chdir() to '$cvs_dir'.");
        print_warning("Skipping '$cvs_dir'.");
        return;
    }

    local @main::changed_files;
    find(\&wanted, '.');

    if ( @main::changed_files ) {
        my $stats_ref = commit_files($cws, \@main::changed_files, $cvs_dir);

        $global_stats{'merged'} += $stats_ref->{'merged'};
        $global_stats{'moved'} += $stats_ref->{'moved'};
        $global_stats{'anchor'} += $stats_ref->{'anchor'};
        print_message(" ========== '$cvs_dir' stats: ==========") if scalar(%{$stats_ref});
        print_message("Commit file(s)     : $stats_ref->{'merged'}") if $stats_ref->{'merged'};
        print_message("Move branch tag(s) : $stats_ref->{'moved'}") if $stats_ref->{'moved'};
        print_message("Move anchor tags(s): $stats_ref->{'anchor'}") if $stats_ref->{'anchor'};
    }

    chdir($save_dir);
    return;
}


sub commit_file_action
{
    my $cws                 = shift;
    my $dir                 = shift; # ununsed, remove me
    my $qualified_milestone = shift; # unused and not initialized
    my $file                = shift;

    my $cvs_dir = dirname($file);

    if ( ! -e "$file.resync" ) {
        print_error("Can't find '$file.resync'. Please use the 'cwsresync -m' step on file '$file' first.", 55)
    }

    my $stats_ref = commit_files($cws, [$file], $cvs_dir);

    $global_stats{'merged'} += $stats_ref->{'merged'};
    $global_stats{'moved'} += $stats_ref->{'moved'};
    $global_stats{'anchor'} += $stats_ref->{'anchor'};
    print_message("Commit file(s)     : $stats_ref->{'merged'}") if $stats_ref->{'merged'};
    print_message("Move branch tag(s) : $stats_ref->{'moved'}") if $stats_ref->{'moved'};
    print_message("Move anchor tags(s): $stats_ref->{'anchor'}") if $stats_ref->{'anchor'};

    return;
}

# TODO: put into module later... see also cwsadd.pl
sub get_mws_location
{
    use GenInfoParser;

    my $masterws = shift;
    my $result = 0;

    my $workspace_lst = EnvHelper::get_workspace_lst();
    my $workspace_db = GenInfoParser->new();
    $result = $workspace_db->load_list($workspace_lst);
    if ( !$result ) {
        print_message("Can't load workspace list '$workspace_lst'.");
        return "";
    }
    my $workspace = $workspace_db->get_key($masterws);
    print_error("Master workspace '$masterws' not found in '$workspace_lst' database.", 3) if ( !$workspace );

    my $wslocation = $workspace_db->get_value($masterws."/Drives/o:/UnixVolume");
    print_error("Location of master workspace '$masterws' not found in '$workspace_lst' database.", 3) if ( !defined($wslocation) ) ;

    if (! -d $wslocation) {
        print_message("Master workspace not found at '$wslocation'!") ;
        return "";
    }
    return $wslocation;
}

sub remove_module
{
    my $module_p = shift;

    my $result = 0;

    if ( -l $module_p ) {
        print "unlink module $module_p\n" if $opt_debug;
        $result |= ! unlink $module_p;
    }
    if ( -l  $module_p.".lnk" ) {
        print "unlink module $module_p.lnk\n" if $opt_debug;
        $result |= ! unlink "$module_p.lnk";
    }
    if ( -d $module_p ) {
        print "rm -rf $module_p\n" if $opt_debug;
        $result |= system("rm -rf $module_p");

    } elsif ( -e $module_p ) {
        print "no idea what this is... $module_p\n" if $opt_debug;
        print_error("Couldn't remove $module_p\[.lnk\]. Giving up.", 1);
    }
    return $result;
}

#
# Procedure copies module to specified path
#
sub copyprj_module
{

    my $module_name = shift;
    my $src_dest = shift;
    print "copyprj $module_name\n";

    # hash, that should contain all the
    # data needed by CopyPrj module
    my %ENVHASH = ();
    my %projects_to_copy = ();
    $ENVHASH{'projects_hash'} = \%projects_to_copy;
    $ENVHASH{'no_otree'} = 1;
    $ENVHASH{'no_path'} = 1;
    $ENVHASH{'only_otree'} = 0;
    $ENVHASH{'only_update'} = 1;
    $ENVHASH{'last_minor'} = 0;
    $ENVHASH{'spec_src'} = 0;
    $ENVHASH{'dest'} = "$src_dest";
    $ENVHASH{'prj_to_copy'} = '';
    $ENVHASH{'i_server'} = '';
    $ENVHASH{'current_dir'} = cwd();
    $ENVHASH{'remote'} = '';
    $ENVHASH{'force_checkout'} = 1 if ($opt_force_checkout);
    $ENVHASH{RESYNC_UPDMINOR} = $opt_link if (defined $opt_link);

    $projects_to_copy{$module_name}++;

    CopyPrj::copy_projects(\%ENVHASH);

};

sub get_platforms_hash {
    my $cws = shift;
    my $minor_mk_name = $ENV{UPD} . 'minor.mk';
    my @files;
    my %platforms = ();
    find sub { push @files, $File::Find::name if -f _ && /$minor_mk_name/ }, $ENV{SOLARVER};
    foreach my $entry (@files) {
        do {
            $entry = dirname($entry);
        } while ($entry =~ /[\\\/]inc[\.\w+]?$/o);
        $platforms{basename($entry)}++;
    };
    $platforms{$ENV{INPATH}}++;
    return %platforms;
}

#
# remove all output trees
#
sub remove_output_trees {
    my $cws = shift;
    my %platforms = get_platforms_hash($cws);
    my $stand_dir = $ENV{SRC_ROOT};
    if (!opendir(SOURCE_ROOT, $stand_dir)) {
        print_error ("Root dir of child workspace not accessible: $!", 1);
    };
    my @found_dirs = readdir(SOURCE_ROOT);
    closedir SOURCE_ROOT;
    my $module_dir = '';
    my @warnings = ();
    foreach my $module (@found_dirs) {
        $module_dir = "$stand_dir/$module";
        next if (!-d $module_dir);
        print_message("Removing output trees from $module...");
        foreach my $plarform (keys %platforms) {
            my $output_tree = "$module_dir/$plarform";
            next if (!-d $output_tree);
            if (!rmtree($output_tree, 0, 1)) {
                push(@warnings, $output_tree);
            };
        }
    };
    print_message("Removing solver ...");
    foreach my $platform (keys %platforms) {
        my $output_tree = $ENV{SOLARVERSION} . "/$platform";
        next if (!-d $output_tree);
        if (!rmtree($output_tree, 0, 1)) {
            push(@warnings, $output_tree);
        };
    };
    print_warning("'$_' cannot be deleted. Please remove it manually") foreach(@warnings);
    print_message("Please run configure & bootstrap again\n") if !($sointernal);
};

#
# Update the sources to the correspondent master tag
#
sub update_sources {
    my ($cws, $new_master, $milestone) = @_;
    my @added_modules = $cws->modules();
    my %added_modules_hash = ();
    my ($master_branch_tag, $cws_branch_tag, $cws_root_tag) = $cws->get_tags($new_master, $milestone);
    my $master_milestone_tag = $cws->get_master_tag($new_master, $milestone);
    my $stand_dir = $ENV{SRC_ROOT};
    $added_modules_hash{$_}++ foreach (@added_modules);
    if (!opendir(SOURCE_ROOT, $stand_dir)) {
        print_error("Root dir of child ($stand_dir) workspace not accessible: $!", 1);
    };

    my @found_dirs = ();
    my $cvs_module;
    my %cvs_aliases;
    if ($opt_skip_update) {
        print "Skipping main tree update\n";
    }
    else {
        @found_dirs = readdir(SOURCE_ROOT);
        closedir(SOURCE_ROOT);
        # TODO clean this incredible mess up
        $cvs_module = get_cvs_module('solenv'); # solenv always on OOo CVS server
        %cvs_aliases = $cvs_module->get_aliases_hash();
    }

    foreach my $module (@found_dirs) {
        next if (!-d $stand_dir . "/$module/CVS");
        print "\tUpdating '$module'";
        $cvs_module->module($module);
        my $result ='';
        if (defined $added_modules_hash{$module}) {
            print " with '$cws_branch_tag' ...\n";
            $result = $cvs_module->update($stand_dir, $cws_branch_tag, '-dP');
            delete $added_modules_hash{$module};
        } elsif (defined $cvs_aliases{$module}) {
            print " with $master_milestone_tag' ...\n";
            $result = $cvs_module->update($stand_dir, $master_milestone_tag, '-dP');
        } else {
            print_warning("... Unknown module. Skipping...");
            next;
        };
        $cvs_module->handle_update_information($result);
    };
    register_cws_milestone($cws, $new_master, $milestone);
    return;
};

sub register_cws_milestone {
    my ($cws, $new_master, $milestone) = @_;
    if ( $cws->master() ne $new_master ) {
        my @push_return = $cws->set_master_and_milestone($new_master, $milestone);
        if ( ($push_return[0] ne $new_master) || ($push_return[1] ne $milestone) ) {
            print_error("Couldn't push new master and milestone to database", 1);
        };
    } else {
        my $push_return = '';
        $push_return = $cws->milestone( $milestone );
        if ( $push_return ne $milestone ) {
            print_error("Couldn't push new milestone to database", 1);
        }
    }
    print_message("Current milestone of CWS updated to '$milestone'.");
    print_message("Remove the old and most likely incompatible module output trees and solver with:");
    print_message("\tcwsresync -r");


}

# Implements the link action: relink all modules and update solver
sub relink_cws_action
{
    my $cws                 = shift;
    my $dir                 = shift;  # ignore, this is never set
    my $qualified_milestone = shift;

    my $cws_master = $cws->master();

    my ($new_master, $milestone);
    if ( $qualified_milestone =~ /:/ ) {
        ($new_master, $milestone) = split(/:/, $qualified_milestone);
    }
    else {
        $new_master = $cws_master;
        $milestone  = $qualified_milestone;
    }

    # ause: Deine Spielwiese

    no warnings;
    my $result = 0;
    my $success = 0;
    my $sourceroot;
    my $mws_location;
    my $mws_accessible = 0;
    my $dest_dir;
    my @found_platforms;
    my @opt_platforms;
    my $found_resync_flags = 0;

    print_message("Doing some checks ...");

    # hack to get the milestone :-(((((
    if ( ! defined($cws->milestone()))
    {
        $cws->milestone($ENV{UPDMINOR});# = $ENV{UPDMINOR};
    }

    # milestone is different from the current milestone
    if ( "$new_master" eq "$cws_master" ) {
        print_error("Child workspace \"".$cws->child()."\" already based on milestone \"$milestone\"", 1) if $cws->milestone() eq $milestone;
    }
    return update_sources($cws, $new_master, $milestone) if ( !($sointernal) ); # HACK

    # SOURCE_ROOT set correct
    print_error("Environment variable \"SOURCE_ROOT\" not set.", 1) if ! defined($ENV{SOURCE_ROOT});
    $sourceroot = $ENV{SOURCE_ROOT};
    print_error("Environment variable \"SOURCE_ROOT\" pointing to something incorrect.", 1) if ! -d "$sourceroot/".$cws_master."/src.".$cws->milestone();

    # desired milestone doesn't exist in cws dir or mws changes
    if ( "$new_master" eq "$cws_master" ) {
        print_error("Looks like there is already a milestone \"$milestone\" in $sourceroot/".$cws_master.".", 1) if  -d "$sourceroot/".$cws_master."/src.$milestone";

        my @checklist = glob( "$sourceroot/$cws_master/*/inc.$milestone/*.mk" );
        print_message("Looks like there is already a milestone \"$milestone\" in $sourceroot/".$cws_master." output trees.") if $#checklist != -1;
    }

    # mws filesystem accessible
    $mws_location = get_mws_location($new_master);
    if ( "$mws_location" ne "" ) {
        # our OS isn't windows
        if ( $^O =~ "MSWin32" || $^O =~ "cygwin" ) {
            print_error("Sorry! not for windows",2);
        }
        $mws_accessible = 1;
    } else {
        print_message("Trying without access to master workspace.");
        $mws_accessible = 0;
    }

    #check if sourceroot points to mws location
    print "$sourceroot <-> $mws_location\n" if $opt_debug;
    my $mws_location_string = $mws_location;
    if ( $mws_location_string =~ /\/net/ ) {
        my @tmplst = split /\//, $mws_location;
        print "list @tmplst\n" if $opt_debug;
        shift @tmplst;
        shift @tmplst;
        shift @tmplst;
        print "list @tmplst\n" if $opt_debug;
        $mws_location_string = "/".join '/', @tmplst;
    }
    print "$sourceroot <-> $mws_location_string\n" if $opt_debug;
    if ( $sourceroot =~ /$mws_location_string/ ) {
        print_error ("Root dir of child workspace and master directory are too similar\n$sourceroot <-> *$mws_location_string", 1)
    }

    print_message("Updating solver.");
    my @added_modules = $cws->modules();
    if ( $mws_accessible )
    {
        require sync_dir; import sync_dir;
        #TODO: check for complete mws milestone

        print_message("Removing previous solver...");
        # find all existing output trees in cws
        $result = opendir( SOLVER, "$sourceroot/".$cws_master);
        if ( !$result ){ print_error ("Root dir of child workspace not accessible: $!", 1) };
        my @found_dirs = readdir( SOLVER );
        closedir( SOLVER );

        foreach my $dir_candidate ( @found_dirs )
        {
            #remove . and ..
            next if ( $dir_candidate eq "." || $dir_candidate eq ".." );
            # check for the remains of previous tries...
            if ( -d "$sourceroot/$cws_master/$dir_candidate/inc.$milestone") {
                # check if there is a complete tree
                if ( -f "$sourceroot/$cws_master/$dir_candidate/inc.$milestone/$platform_resynced_flag" ) {
                    $found_resync_flags++;
                    next;
                }
                # try to remove rubbish...
                $result = system("rm -rf $sourceroot/$cws_master/$dir_candidate/*.$milestone");
                if ( $result ) {
                    print_error( "Couldn't cleanup \"$sourceroot/$cws_master/$dir_candidate/*.$milestone\". Please do manually!", 1 );
                }
                # ...and fake the old minor.
                $result = mkpath( "$sourceroot/".$cws_master."/$dir_candidate/inc.".$cws->milestone(), 0, 0777-$umask);
            }
            if ( -d "$sourceroot/".$cws_master."/$dir_candidate/inc.".$cws->milestone() )
            {
                push @found_platforms, $dir_candidate;
            }
        }
        if ( !@found_platforms )
        {
            print_message("No output trees to remove");
            $success = 0;
        }

        # remove them
        $result = 0;
        foreach my $platform ( @found_platforms ) {
            next if ( -f "$sourceroot/$cws_master/$platform/inc.$milestone/$platform_resynced_flag" );
            print_message("Removing $platform");
            if ( -d "$sourceroot/$cws_master/$platform") {
                # make sure it's recognized when restarting
                my $tmp_result = mkpath( "$sourceroot/$cws_master/$platform/inc.$milestone", 0, 0777-$umask);
                $result |= system("rm -rf $sourceroot/$cws_master/$platform/*.".$cws->milestone());
            } else {
                print_error("\"$sourceroot/$cws_master/$platform\" isn't a directory,", 0);
                print_error("trying to rename...", 0);
                $result |= system("mv $sourceroot/$cws_master/$platform $sourceroot/$cws_master/$platform.renamed");
            }
        }

        print_error("Couldn\'t remove existing solver on child workspace.", 1) if $result;

        # find all existing output trees in mws or use list
        # no opt list yet - take the trees that were use before resync
        @opt_platforms = @found_platforms;
        @found_platforms = ();
        # find platforms to copy
        if ( $#opt_platforms != -1 || $found_resync_flags > 0 ) {
            @found_platforms = map( lc, @opt_platforms );
        } else {
            print_error("this is an implementaion bug!", 1);
        }
        # copy all wanted output trees
        $sync_dir::do_keepzip = 1;
        sync_dir::set_excludelist( \@added_modules ); # omit added modules
        sync_dir::addto_excludelist(["instset_native", "instsetoo_native"]); # omit instset* modules
        my $btarget = "finalize";
        foreach my $platform ( @found_platforms )
        {
            # don't copy tree that was already successful
            next if ( -f "$sourceroot/$cws_master/$platform/inc.$milestone/$platform_resynced_flag" );
            %sync_dir::done_hash = ();
            print "Create copy of solver for $platform ( ~ 1GB disk space needed !)\n";
            my $zipsource = "$mws_location/".$new_master."/$platform/zip.$milestone";
            my $copy_dest = "$sourceroot/".$cws_master."/$platform/zip.$milestone";
            if ( -d "$sourceroot/".$cws_master."/$platform" )
            {
            #    print_error ("$dir/$platform : Please restart on a clean directory tree!", 1);
            }
            if ( ! -d $copy_dest )
            {
                $result = mkpath($copy_dest, 0, 0777-$umask);
                if ( !$result ){ print_error ("Cannot create output tree $copy_dest : $!", 1) };
            }

            my $unzip_dest = $copy_dest;
            $unzip_dest =~ s/(.*)\/.*$/$1/;

            if ( ! -e "$unzip_dest/prepared" ) {
                $result = sync_dir::prepare_minor_unzip( $unzip_dest, ".".$milestone );
                open( PREPARED, ">$unzip_dest/prepared");
                close( PREPARED );
            }

            STDOUT->autoflush(1);
            $result = &sync_dir::recurse_unzip( $zipsource, $copy_dest, $btarget );
            STDOUT->autoflush(0);
            if ( $result )
            {
                # renaming back before exit
                $result = sync_dir::finish_minor_unzip( $unzip_dest, ".".$milestone );
                print_error ("Copying files to $copy_dest failed : $!", 1);
            }
            $result = sync_dir::finish_minor_unzip( $unzip_dest, ".".$milestone );
            unlink "$unzip_dest/prepared.$milestone" if -e "$unzip_dest/prepared.$milestone";
            open( COMPLETE, ">$sourceroot/$cws_master/$platform/inc.$milestone/$platform_resynced_flag");
            close( COMPLETE );

            # cleanup: remove zip files
            print "remove zip.$milestone\n";
            $result = system("rm -rf $copy_dest");
            if ( $result ) {
                print_warning ("Could not clean up zip file directory 'copy_dest'");
            }

        }
        foreach my $oneextra ( @xtra_files )
        {
            my @globlist = glob( "$mws_location/".$new_master."/[!s]*/*.$milestone/$oneextra" );
            if ( $#globlist == -1 ) {
                print "tried $oneextra in $mws_location/".$new_master."/[!s]*/*.$milestone/$oneextra\n";
            }
            foreach my $onefile ( @globlist )
            {
                my $destfile = $onefile;
                my $m_dir = "$mws_location/".$new_master;
                my $c_dir = "$sourceroot/".$cws_master;
                $destfile =~ s#$m_dir#$c_dir#;

                if ( -d dirname( $destfile ))
                {
                    $result = copy( $onefile,  $destfile);
                    if ( !$result ){ print_error ("Copying $onefile to CWS failed: $!", 1) };
                    # preserve timestamp
                    my @from_stat = stat($onefile);
                    utime($from_stat[9], $from_stat[9], $destfile);
                }
            }
        }

    } else {
        print_error("solver tree resync without mws access not yet implemented", 5);
    }
    print_message("Recreating CWS source tree with MWS milestone '$milestone'.");
    if ( $mws_accessible ) {
        # all but added modules
        my %modules_hash =();
        print "debug: added modules: @added_modules\n" if $opt_debug;
        $result = opendir( SOURCE, "$mws_location/".$new_master."/src.".$milestone);
        if ( !$result ){ print_error ("Source dir of master workspace not accessible: $!", 1) };
        my @mws_found_modules = readdir( SOURCE );
        closedir( SOURCE );
        foreach my $module (@mws_found_modules) { $modules_hash{$module}++; }
        delete $modules_hash{"."};
        delete $modules_hash{".."};
        foreach my $module (@added_modules) { delete $modules_hash{$module}; }

        if ( !scalar(keys(%modules_hash)) )
        {
            print_error("No valid source tree to copy", 0);
            $success = 0;
        }
        print "debug: number of modules left: ".scalar(keys(%modules_hash))."\n" if $opt_debug;
        # now remove them
        print_message("Removing old modules");
        $dest_dir = "$sourceroot/".$cws_master."/src.".$cws->milestone();
        $result = 0;

        # don't touch solenv if added
        if ( defined $modules_hash{"solenv"} ) {
            # backup "solenv" for restarting...
            $result = system("mv $dest_dir/solenv $dest_dir/solenv.keep");
            print_error("Couldn't backup \"solenv\". You better check your tree...", 1) if $result;
        }

        foreach my $module ( keys %modules_hash ) {
            my $module_path = $dest_dir."/$module";
            $result |= remove_module( $module_path );
        }

        print_error("Couldn\'t cleanup source tree. Please check.", 1) if ( $result );

        # copy instset, res, solenv,  link all missing
        # preparing pseudo environment for copyprj
        $ENV{SRC_ROOT}="$mws_location/".$new_master."/src.$milestone";

        $success = 1;
        foreach my $module ( keys %modules_hash ) {
            # copy modules which are required to be accessable with their
            # orginal name without .lnk extension
            if (defined $obligatory_modules{$module}) {
               &copyprj_module($module, $dest_dir);
               next ;
            };
            if ( -d "$mws_location/".$new_master."/src.$milestone/$module" ) {
                if ( -l "$dest_dir/$module.lnk" &&
                    readlink( "$dest_dir/$module.lnk" ) eq "$mws_location/".$new_master."/src.$milestone/$module" )
                {
                    next;
                } else {
                # better...
                    $result = symlink( "$mws_location/".$new_master."/src.$milestone/$module", "$dest_dir/$module.lnk");
                }
                if ( !$result ) {
                    print_error ( "Couldn't create link from $mws_location/".$new_master."/src.$milestone/$module to $dest_dir/$module", 0);
                    $success = 0;
                }
            }
        }
        if ( defined $modules_hash{"solenv"} ) {
            my $solenv_path = $dest_dir."/solenv.keep";
            $result |= remove_module( $solenv_path );
        }

    } else {
        print_error("source tree resync without mws access not yet implemented", 5);
        # remove all but added modules
        # checkout all missing
    }

    # rename src.* directory
    rename $dest_dir, "$sourceroot/".$cws_master."/src.$milestone";

    # master changed?
    if ( $cws_master ne $new_master ) {
        # push new master if different
        my @push_return = $cws->set_master_and_milestone($new_master, $milestone);
        if ( ($push_return[0] ne $new_master) || ($push_return[1] ne $milestone) ) {
            print_error("Couldn't push new master and milestone to database");
        } else {
            print_message("Successfully pushed new master and milestone to database");
        }

        # rename WORKSPACE directory if different
        chdir ($sourceroot) if ( cwd() eq "$sourceroot/cws_master" );
        rename "$sourceroot/$cws_master", "$sourceroot/$new_master";
        chdir ("$sourceroot/$new_master") if ( cwd() eq "$sourceroot" );
    } else {
        my $push_return = $cws->milestone( $milestone );
        if ( $push_return ne $milestone ) {
            print_error("Couldn't push new milestone to database");
        } else {
            print_message("Successfully pushed new milestone to database");
        }
    }

    # resync done. now remove all $platform_resynced_flag
    my @completelist = glob( "$sourceroot/$new_master/*/inc.$milestone/$platform_resynced_flag" );
    unlink( @completelist );
    return;
}

# Low level merge file routine:
# Merge changes on master copy into the child copy of the file.
sub merge_files
{
    my $cws_anchor_tag    = shift;
    my $milestone_tag     = shift;
    my $changes_ref       = shift;
    my $cvs_handle        = shift;
    my $module            = shift; # needed for proper logging

    my @new_files;
    my @removed_files;
    my @move_tags_files;
    my @merge_candidates;
    my %module_stats = ('new'       => 0,
                        'removed'   => 0,
                        'merged'    => 0,
                        'moved'     => 0,
                        'anchor'    => 0,
                        'conflict'  => 0,
                        'alert'     => 0,
                        'ignored'   => 0
                       );

    foreach ( @${changes_ref} ) {
        my $file = $_->[0];
        my $old_rev = $_->[1];
        my $new_rev = $_->[2];

        if ( exists $resync_silent_ignore_files{basename($file)} ) {
            # skip it without any comment at all
            next;
        }

        # sort by type of merge action
        if ( !$old_rev && !$new_rev ) {
            push(@removed_files, $file);
        }
        elsif ( !$old_rev ) {
            push(@new_files, [$file, $new_rev]);
        }
        else {
            push(@merge_candidates, [$file, $old_rev, $new_rev]);
        }
    }

    # Handle files which have recently been added on the MWS.
    # For new files we don't need to check the status of the
    # file in the CWS, just do a simple existence check.
    my $n_new_files = @new_files;
    if ( $n_new_files ) {
        print "  ... processing $n_new_files new file(s) ...\n";
        foreach ( @new_files ) {
            my $file    = $_->[0];
            my $new_rev = $_->[1];
            # Check if file has been added on two CWSs, once in this CWS
            # and once in an already integrated CWS.
            if (  -e $file ) {
                # We alert the user and skip the file.
                print "\tA\t$file: has been added independently in MWS and CWS. Skipping. Please check!\n";
                plog("A\t$module/$file: has been added independently in MWS and CWS. Skipping. Please check!");
                $module_stats{'alert'}++;
                $module_stats{'skipped'}++;
                next;
            }
            write_resync_comment($file, 'new', $milestone_tag, undef, $new_rev);
            print "\tN\t$file: added, schedule move tag\n";
            $module_stats{'new'}++;
        }
    }

    # Handle files which have recently been removed on the MWS.
    # We check the status of these files in the CWS to be able to warn
    # if a file which to be removed which has been changed in the MWS
    my $n_removed_files = @removed_files;
    if ( $n_removed_files ) {
        print "  ... processing $n_removed_files removed file(s) ...\n";
        my $stati_ref = $cvs_handle->stati(\@removed_files);
        # sanity check
        my $n_stati_ref = @{$stati_ref};
        if ( $n_stati_ref != $n_removed_files ) {
            print_error("INTERNAL ERROR: can't fetch the status for all to be removed files", 8);
        }
        my @rfiles;
        for (my $i = 0; $i < $n_removed_files; $i++) {
            my $file        = $removed_files[$i];
            my $working_rev = $stati_ref->[$i][2];
            my $branch_rev  = $stati_ref->[$i][4];
            if ( !defined($working_rev) ) {
                # File has already been removed on CWS, ignore.
                print "\tI\t$file: file already removed on CWS, ignored.\n";
                $module_stats{'ignored'}++;
                next;
            }
            if ( $working_rev =~ /$branch_rev\.\d+/ ) {
                # Example: working rev 1.5.260.1, branch rev 1.5.260
                print "\tA\t$file: has been removed on MWS but is changed on CWS. Will remove file. Please check!\n";
                plog("A\t$module/$file: has been removed on MWS but is changed on CWS. Will remove file. Please check!");
                # Note: we still procceed with removing this file. Thus this file is counted
                # as alerted and removed.
                $module_stats{'alert'}++;
            }
            push(@rfiles, $file);
        }
        my $n_rfiles = @rfiles;
        if ( $n_rfiles ) {
             $cvs_handle->remove_files(\@rfiles);
            foreach my $file ( @rfiles ) {
                write_resync_comment($file, 'removed', $milestone_tag, undef, undef, );
                print "\tR\t$file: removed, schedule commit\n";
                $module_stats{'removed'}++;
            }
        }
    }

    # Handle files in the merge list. Fetch status first to check if we get
    # away with "move tag". We also need to check for binary files and
    # files which have been removed in the CWS.
    my $n_merge_candidates = @merge_candidates;
    if ( $n_merge_candidates ) {
        print "  ... processing $n_merge_candidates merge candidate(s) ...\n";
        my @stati_lists = ();
        foreach (@merge_candidates) {
            push(@stati_lists, $_->[0]);
        }
        my $stati_ref = $cvs_handle->stati(\@stati_lists);
        # sanity check
        my $n_stati_ref = @{$stati_ref};
        if ( $n_stati_ref != $n_merge_candidates ) {
            print_error("INTERNAL ERROR: can't fetch the status for all to be merged files", 8);
        }
        my @mfiles;
        foreach (my $i = 0; $i < $n_merge_candidates; $i++) {
            my $file        = $merge_candidates[$i][0];
            my $old_rev     = $merge_candidates[$i][1];
            my $new_rev     = $merge_candidates[$i][2];
            my $status      = $stati_ref->[$i][1];
            my $working_rev = $stati_ref->[$i][2];
            my $branch_rev  = $stati_ref->[$i][4];
            my $is_binary   = (defined($stati_ref->[$i][5]) && $stati_ref->[$i][5] =~ /kb/) ? 1 : 0;

            if ( ($status eq 'Up-to-date' || $status eq 'Needs Checkout') && !defined($working_rev) ) {
                # Special case: file has been removed in CWS but there
                # were changes between old and new MWS milestones.
                # Resolution: Do nothing, skip this file. The file
                # remains being removed on this CWS.
                print "\tA\t$file: has been removed in CWS, but changes in MWS are pending. Skipping. Please check!\n";
                plog("A\t$module/$file: has been removed in CWS, but changes in MWS are pending. Skipping. Please check!");
                $module_stats{'alert'}++;
                $module_stats{'skipped'}++;
                next;
            }
            # Sanity check
            if ( !defined($branch_rev) || !defined($working_rev) ) {
                print_error("Internal Error: merge_files(): branch_rev or working_rev undefined $file\n",77);
            }
            if ( exists $resync_always_move_tags{basename($file)} ) {
                # Incredible HACK, always move both tags to the milestone for these files,
                # REMOVE_ME: as soon we get rid of defs files on trunk this should be removed
                write_resync_comment($file, 'moved',  $milestone_tag, $old_rev, $new_rev);
                print "\tT\t$file: schedule move tag.\n";
                $module_stats{'moved'}++;
                next;
            }
            if ( $branch_rev =~ /$working_rev\.\d+/ ) {
                # Example: branch rev 1.5.260, working rev 1.5
                # Joy, we get away with just a "move tag".
                write_resync_comment($file, 'moved',  $milestone_tag, $old_rev, $new_rev);
                print "\tT\t$file: schedule move tag.\n";
                $module_stats{'moved'}++;
                next;
            }
            if ( $is_binary ) {
                # We got changes pending in the MWS and we have changes in the CWS.
                # Since we can't merge binary files we give up here. Sure, we could
                # either favor the MWS or the CWS version, but there is no way to decide
                # which one is better. We alert the user and skip the file.
                print "\tA\t$file: binary file has been changed in CWS and in MWS. Skipping. Please check!\n";
                plog("A\t$file: binary file has been changed in CWS and in MWS. Skipping. Please check!");
                $module_stats{'alert'}++;
                $module_stats{'skipped'}++;
                next;
            }
            push (@mfiles, [$file, $old_rev, $new_rev]);
        }

        my $n_mfiles = @mfiles;
        if ( $n_mfiles ) {
            print "  ... do $n_mfiles actual merge(s) ...\n";

            # the merge_files() API wants a reference to a plain list
            my @to_be_merged_files;
            foreach (@mfiles) {
                push(@to_be_merged_files, $_->[0]);
            }

            my ($conflicts_ref, $already_merged_ref)
                        = $cvs_handle->merge_files(\@to_be_merged_files, $cws_anchor_tag, $milestone_tag);

            # for easier searching
            my %conflicts_hash;
            foreach (@{$conflicts_ref}) {
                $conflicts_hash{$_}++;
            }
            my %already_merged_hash;
            foreach (@{$already_merged_ref}) {
                $already_merged_hash{$_}++;
            }

            foreach (@mfiles) {
                my $file    = $_->[0];
                my $old_rev = $_->[1];
                my $new_rev = $_->[2];
                if ( exists $already_merged_hash{$file} ) {
                    print "\tT\t$file: contains differences, schedule move anchor\n";
                    $module_stats{'anchor'}++;
                    write_resync_comment($file, 'anchor', $milestone_tag, $old_rev, $new_rev);
                }
                elsif ( exists $conflicts_hash{$file} ) {
                    print "\tC\t$file: conflict, schedule commit after resolution.\n";
                    plog("C\t$module/$file: conflict, schedule commit after resolution.");
                    write_resync_comment($file, 'merged', $milestone_tag, $old_rev, $new_rev);
                    $module_stats{'conflict'}++;
                }
                else {
                    print "\tM\t$file: merged, schedule commit.\n";
                    $module_stats{'merged'}++;
                    write_resync_comment($file, 'merged', $milestone_tag, $old_rev, $new_rev);
                }
            }
        }
    }
    return \%module_stats;
}

# Low level commit_files routine:
# Commits files to the childworkspace or move tags.
# Requires a valid .resync files next to the CVS files
sub commit_files
{
    my $cws       = shift;
    my $files_ref = shift;
    my $cvs_dir   = shift;

    my %module_stats = (
                        'merged' => 0, # aka commit
                        'moved' => 0,
                        'anchor' => 0
                       );
    my @ci_files;
    my @remove_files;
    my @move_both_tags_files;
    my @move_anchor_tag_files;
    my @move_anchor_to_master_head_files;
    my @possible_conflict_files;

    my $milestone_tag;
    my $master_head;

    # collect all *.resync files
    foreach (@{$files_ref}) {
        if ( !open(CHECKIN, "<$_.resync" ) ) {
            print_error("can't open $_.resync: $!", 7);
        }
        my @resync_comment = <CHECKIN>;
        close(CHECKIN);

        my $type_line = shift(@resync_comment);

        my ($type, $old_rev, $tag, $new_rev);
        if ( $type_line =~ /^RESYNC (\w+) (\w+) ([\w\.]+) ([\w\.]+)/ ) {
            $type    = lc($1);
            $tag     = $2;
            $old_rev = $3;
            $new_rev = $4;
        }
        else {
            print_error("$_.resync has an invalid format", 8);
            return 'failure';
        }

        # shift the line with "Everything below this line will be added to the revision comment."
        shift(@resync_comment);

        # sanity checks to guard against a mix of resyncs targets
        if ( $type ne 'dead' && defined($milestone_tag) && $tag ne $milestone_tag) {
            print_error("detected more than one resync milestone tag: '$milestone_tag' and '$tag'", 9);
        }
        if ( $type eq 'dead' && defined($master_head) && $tag ne $master_head ) {
            print_error("detected more than one resync at master tags: '$master_head and '$tag'", 9);
        }

        # set target
        if ( $type ne 'dead' && !defined($milestone_tag) ) {
            $milestone_tag = $tag;
        }
        if ( $type eq 'dead' && !defined($master_head) ) {
            $master_head = $tag;
        }

        if ( $type eq 'moved' || $type eq 'new') {
            # just move both tags
            push(@move_both_tags_files, $_);
        }
        elsif ( $type eq 'anchor' ) {
            # just move the anchor tag
            push(@move_anchor_tag_files, $_);
        }
        elsif ( $type eq 'merged' ) {
            # commit and move anchor tags
            push(@ci_files, [$_, $type, $old_rev, $new_rev, \@resync_comment]);
            # these files need to be checked for conflict markers
            push(@possible_conflict_files, $_);
        }
        elsif ( $type eq 'removed') {
            # remove, commit and move anchor tags
            push(@remove_files, $_);
            push(@ci_files, [$_, $type, $old_rev, $new_rev, \@resync_comment]);
        }
        elsif ( $type eq 'dead' ) {
            # can occur here only if there has been an interruption
            # between the commit of removed files and the move
            # of the anchor tag to the master head
            push(@move_anchor_to_master_head_files, $_);
        }
    }


    check_for_conflict_markers(\@possible_conflict_files);

    my $cvs_handle = get_cvs_handle($cws, 'directory', $cvs_dir);

    my $n_remove_files = @remove_files;
    if ( $n_remove_files ) {
        print "  ... preparing removal of $n_remove_files file(s) ...\n";
        my $n = unlink(@remove_files);
        if ( $n != $n_remove_files) {
            print_error("can't unlink() files scheduled for removal.", 22);
        }
        $cvs_handle->remove_files(\@remove_files);
    }

    # commit files
    # we do single commits, because the comments are differing for each file

    my $n_ci_files = @ci_files;

    my ($master_branch_tag, $cws_branch_tag, $cws_anchor_tag) = $cws->get_tags();

    if ( !defined($master_head) ) {
        # Determine new master from milestone_tag. We can't use $master_branch_tag
        # here because after resyncing we might have a new master due to
        # a cross master resync and the CWS itself is not yet updated
        # to the new master.
        my ($master) = split(/_/, $milestone_tag);
        my $new_master_branch_tag = $cws->get_master_branch_tag($master);
        $master_head = $new_master_branch_tag ? $new_master_branch_tag : 'HEAD';
    }

    if ( $n_ci_files ) {
        print "  ... commit $n_ci_files file(s) ...\n";
    }
    foreach (@ci_files) {
        my ($file, $type, $old_rev, $new_rev, $resync_comment_ref) = @{$_};
        my @comment;
        if ( $type eq 'merged' ) {
            @comment = ("RESYNC: ($old_rev-$new_rev); FILE MERGED", @{$resync_comment_ref});
        }
        elsif ( $type eq 'removed' ) {
            @comment = ("RESYNC:; FILE REMOVED");
        }
        else {
            print_error("INTERNAL ERROR: unknown commit type", 11);
        }
        print "\t $file: commit ...\n";
        $cvs_handle->commit_files([$file], \@comment);
        if ( $type eq 'removed' ) {
            # Uh oh, file has been removed in master workspace.
            # We can't place the anchor tag on the milestone tag
            # because it's simply not there. but we know that
            # it must be the top level revision of the master branch.
            # In this case we can set the Anchor tag to the revision
            # which corresponds to the head of the master branch.

            # overwrite .resync file with a 'dead' style request, in case
            # of an interruption between commit and the move anchor tag step.
            # $old_rev and $new_rev are just dummies, the $master_head is relevant
            write_resync_comment($file, 'dead', $master_head, '0.0', '0.0');
            push(@move_anchor_to_master_head_files, $file);
        }
        else {
            # overwrite .resync file with a move anchor style request, in case
            # of an interruption between commit and move anchor tag step.
            # $old_rev and $new_rev are just dummies, the $milestone_tag is relevant
            write_resync_comment($file, 'anchor', $milestone_tag, '0.0', '0.0');
            push(@move_anchor_tag_files, $file);
        }
        $module_stats{'merged'}++;
    }


    my $n_move_both_tags_files = @move_both_tags_files;
    if ( $n_move_both_tags_files ) {
        print "  ... move branch tag for $n_move_both_tags_files file(s) ...\n";

        my $tagged_files_ref = $cvs_handle->tag_files(\@move_both_tags_files, $cws_branch_tag, 1,
                                                        $milestone_tag);
        my $n_tagged_files = @{$tagged_files_ref};
        if ( $n_move_both_tags_files != $n_tagged_files ) {
            print_warning("expected $n_move_both_tags_files tag operations, got $n_tagged_files.", 0);
            plog("A\t $cvs_dir: expected $n_move_both_tags_files tag operations, got $n_tagged_files.");
        }
        # overwrite .resync file with a move anchor style request, in case
        # of an interruption between commit and move anchor tag step.
        foreach (@move_both_tags_files) {
            write_resync_comment($_, 'anchor', $milestone_tag, '0.0', '0.0');
        }
        push(@move_anchor_tag_files, @move_both_tags_files);
        $module_stats{'moved'} += $n_move_both_tags_files;
    }

    my $n_move_anchor_to_master_head_files = @move_anchor_to_master_head_files;

    if ( $n_move_anchor_to_master_head_files ) {
        print "  ... move anchor tag of removed files to to branch head '$master_head' for $n_move_anchor_to_master_head_files file(s) ...\n";

        my $tagged_files_ref = $cvs_handle->tag_files(\@move_anchor_to_master_head_files,
                                                        $cws_anchor_tag, 0, $master_head);
        my $n_tagged_files = @{$tagged_files_ref};
        if ( $n_move_anchor_to_master_head_files != $n_tagged_files ) {
            print_warning("expected $n_move_anchor_to_master_head_files tag operations, got $n_tagged_files.", 0);
            plog("A\t $cvs_dir: expected $n_move_anchor_to_master_head_files tag operations, got $n_tagged_files.");
        }
        $module_stats{'anchor'} += $n_move_anchor_to_master_head_files;
        unlink_resync_comment_files(\@move_anchor_to_master_head_files);
    }

    my $n_move_anchor_tag_files = @move_anchor_tag_files;
    if ( $n_move_anchor_tag_files ) {
        print "  ... move anchor tag to milestone '$milestone_tag' for $n_move_anchor_tag_files file(s) ...\n";

        my $tagged_files_ref = $cvs_handle->tag_files(\@move_anchor_tag_files, $cws_anchor_tag, 0,
                                                    $milestone_tag);
        my $n_tagged_files = @{$tagged_files_ref};
        if ( $n_move_anchor_tag_files != $n_tagged_files ) {
            print_warning("expected $n_move_anchor_tag_files tag operations, got $n_tagged_files.", 0);
        }
        $module_stats{'anchor'} += $n_move_anchor_tag_files;
        unlink_resync_comment_files(\@move_anchor_tag_files);
    }
    return \%module_stats;
}

sub check_for_conflict_markers
{
    my $files_ref = shift;

    foreach my $file ( @{$files_ref} ) {
        my $conflict = 0;
        my $basename = basename($file);
        open(MERGED_FILE, "<$file") or print_error("can't open '$file' for reading: $!.", 40);
        while (<MERGED_FILE> ) {
            chomp;
            if ( /^<<<<<<< $basename$/ ) {
                $conflict++;
            }
            if ( /^>>>>>>> 1\.\d[\d\.]*$/ ) {
                $conflict++;
            }
        }
        close(MERGED_FILE);
        if ( $conflict ) {
            print_error("found conflict marker in file '$file'", 99);
        }
    }
}

sub unlink_resync_comment_files
{
    my $comment_files_ref = shift;

    foreach ( @{$comment_files_ref} ) {
        if ( !unlink("$_.resync") ) {
            print_error("can't unlink $_.cwsresync!", 30);
        }
    }

}

sub write_resync_comment
{
    my $file          = shift;
    my $type          = shift;
    my $milestone_tag = shift;
    my $old_rev       = shift;
    my $new_rev       = shift;

    if ( !open(RESYNC_COMMENT, ">$file.resync") ) {
        print_error("can't open file '$file.resync'", 7);
    }
    my $uctype = uc($type);
    $old_rev = 'none' if !defined($old_rev);
    $new_rev = 'none' if !defined($new_rev);
    print RESYNC_COMMENT "RESYNC $uctype $milestone_tag $old_rev $new_rev\n";
    if ( $type eq 'removed' && $type eq 'merged' ) {
        print RESYNC_COMMENT "Everything below this line will be added to the revision comment.\n";
    }
    close(RESYNC_COMMENT);
}

sub wanted {
    my $file = $_;

    my ($name, $path, $suffix) = fileparse($file,'\.\w+') if -f $file;

    if ( defined($suffix) && $suffix eq '.resync' ) {
        my $cvs_file;
        if ( length($File::Find::dir) > 2 ) {
            my $dir = substr($File::Find::dir, 2);
            $cvs_file = "$dir/$name";
        }
        else {
            $cvs_file = $name;
        }
        push(@main::changed_files, $cvs_file);
    }
}

sub check_sticky_tag
{
    my $cws     = shift;
    my $cvs_dir = shift;

    my ($master_branch_tag, $cws_branch_tag, $cws_anchor_tag) = $cws->get_tags();
    if ( !open(CVSTAG, "<$cvs_dir/CVS/Tag") ) {
        print_error("'$cvs_dir': can't determine sticky tag.", 0);
        return 0;
    }
    my @lines = <CVSTAG>;
    close(CVSTAG);

    if ( $lines[0] =~ /^T$cws_branch_tag/ ) {
        return 1;
    }
    else {
        print_error("'$cvs_dir': wrong sticky tag, need '$cws_branch_tag'", 0);
        return 0;
    }
}

# Checks specified milestone.
sub verify_milestone_or_exit
{
    my $cws = shift;
    my $qualified_milestone = shift;

    # HEAD is not a milestone but a valid resync target for single files.
    # This is useful if you want to resync a single file against the latest
    # version on a MWS even if that file is not yet part of a valid milestone.
    return if $qualified_milestone eq 'HEAD';

    my ($master, $milestone);
    my $invalid = 0;

    $invalid++ if $qualified_milestone =~ /-/;

    if ( $qualified_milestone =~ /:/ ) {
        ($master, $milestone) = split(/:/, $qualified_milestone);
        $invalid++ unless ( $master && $milestone );
    }
    else {
        $milestone = $qualified_milestone;
    }

    if ( $invalid ) {
        print_error("Invalid milestone", 0);
        usage();
        exit(1);
    }

    $master = $cws->master() if !$master;
    if ( !$cws->is_milestone($master, $milestone) ) {
        print_error("Milestone '$milestone' is not registered with master workspace '$master'.", 2);
    }
}

# Returns milestone tag determined from the
# full qualified milestone name.
sub get_milestone_tag
{
    my $cws                 = shift;
    my $qualified_milestone = shift;

    if ( $qualified_milestone =~ /:/ ) {
        my ($master, $milestone) = split(/:/, $qualified_milestone);
        return uc($master) . "_$milestone";
    }
    else {
        return $cws->master() . "_$milestone";
    }
}

# Retrieve CvsModule object for passed module.
sub get_cvs_module
{
    my $cws    = shift;
    my $module = shift;

    my $cvs_module = CvsModule->new();
    my ($method, $vcsid, $server, $repository);
    if ( $sointernal ) {
        ($method, $vcsid, $server, $repository) = get_cvs_root($cws, $module);
    }
    else {
        # For now just take the configured OOo sever. Later we might implement a mechanism were
        # only known OOo modules are fetched from the OOo server, the rest from a local
        # server
        ($method, $vcsid, $server, $repository) = ($config->get_cvs_server_method(),
                                                   $config->get_cvs_server_id(),
                                                   $config->get_cvs_server(),
                                                   $config->get_cvs_server_repository());
    }

    return undef if  !($method && $vcsid && $server && $repository);

    $cvs_module->module($module);
    $cvs_module->cvs_method($method);
    $cvs_module->vcsid($vcsid);
    $cvs_module->cvs_server($server);
    $cvs_module->cvs_repository($repository);

    return $cvs_module;
}

# Retrieve CwsCvsOps object for passed module.
sub get_cvs_handle
{
    my $cws           = shift;
    my $from_config   = shift; # from config or from disk directory?
    my $module_or_dir = shift;

    my $server_type;

    if ( $from_config eq 'config' ) {
        if ( $sointernal ) {
            my ($method, $vcsid, $server, $repository) = get_cvs_root($cws, $module_or_dir);
            my @elem = split(/\./, $server);
            $server = $elem[0];
            my $local_server = $config->cvs_local_root();

            if ( $local_server =~ /$server/ ) {
                $server_type = 'local';
            }
            else {
                $server_type = 'remote';
            }
        }
        else {
            # For now just take the configured OOo sever. Later we might implement a mechanism were
            # only known OOo modules are fetched from the OOo server, the rest from a local
            # server
            $server_type = 'remote';
        }
    }
    else {
        $server_type = 'directory';
    }

    return undef if !$server_type;

    if ( $opt_debug ) {
        my $log_file = IO::File->new('>>cwsresync.debug.log');
        my $time = localtime();
        $log_file->print("===== $time =====\n");
        return CwsCvsOps->new($config, $server_type, $module_or_dir, $log_file);
    }
    else {
        return CwsCvsOps->new($config, $server_type, $module_or_dir);
    }
}

# Find out which CVS server holds the module, returns
# the elements of CVSROOT.
# TODO: simplify as soon get_cvs_module is gone
sub get_cvs_root
{
    my $cws    = shift;
    my $module = shift;

    my $master = $cws->master();

    my $vcsid = $ENV{VCSID};
    if ( !$vcsid ) {
        print_error("Can't determine VCSID. Please use setsolar.", 5);
    }

    my $workspace_lst = EnvHelper::get_workspace_lst();
    my $workspace_db = GenInfoParser->new();
    my $success = $workspace_db->load_list($workspace_lst);
    if ( !$success ) {
        print_error("Can't load workspace list '$workspace_lst'.", 4);
    }

    my $key = "$master/drives/o:/projects/$module/scs";
    my $cvsroot = $workspace_db->get_value($key);

    if ( !$cvsroot  ) {
        print_warning("No such module '$module' for '$master' in workspace database.");
        return (undef, undef, undef, undef);
    }

    my ($dummy1, $method, $user_at_server, $repository) = split(/:/, $cvsroot);
    $repository =~ s/^\d*//;
    my ($dummy2, $server) = split(/@/, $user_at_server);

    if ( ! ($method && $server && $repository ) ) {
        print_error("Can't determine CVS server for module '$module'.", 0);
        return (undef, undef, undef, undef);
    }

    return ($method, $vcsid, $server, $repository);
}


sub print_message
{
    my $message     = shift;

    print "$script_name: ";
    print "$message\n";
    return;
}

sub print_warning
{
    my $message     = shift;

    print STDERR "$script_name: ";
    print STDERR "WARNING: $message\n";
    return;
}

sub print_error
{
    my $message     = shift;
    my $error_code  = shift;

    print STDERR "$script_name: ";
    print STDERR "ERROR: $message\n";

    if ( $error_code ) {
        print STDERR "\nFAILURE: $script_name aborted.\n";
        exit($error_code);
    }
    return;
}

sub plog
{
    my $message = shift;

    push(@problem_log, $message);
}

sub print_plog
{
    if ( @problem_log ) {
        print_message("========== Problem Log ==========");
        foreach ( @problem_log ) {
            print "\t$_\n";
        }
        print_message("========== End Problem Log ==========");
    }
}

sub usage
{
    my $sw_skip_checkout = !($sointernal) ? " [-f] " : " ";
    print STDERR "Usage:\n";
    print STDERR "cwsresync [-h] [-d dir] [-F] -m <milest.> <all|mod.|dir|file> [mod.|dir|file ...]\n";
    print STDERR "cwsresync [-h] [-d dir] -m HEAD <file> [file ...]\n";
    print STDERR "cwsresync [-h] [-d dir] -r|-c <all|module|dir|file> [module|dir|file ...]\n";
    print STDERR "cwsresync [-h]" . $sw_skip_checkout ."-l <milestone>\n";
    print STDERR "Synchronize child workspace mod./dirs/files ";
    print STDERR "with the latest master workspace changes \n";
    print STDERR "Options:\n";
    print STDERR "\t-h\t\thelp\n";
    print STDERR "\t-d dir\t\toperate in directory dir\n";
    print STDERR "\t-F\t\tforce checkout of complete modules\n";
    print STDERR "\t-m milestone\tmerge changes from MWS into CWS\n";
    print STDERR "\t-c\t\tcommit the merged files to CWS\n";
    print STDERR "\t-l milestone\trenew solver, relink modules to new milestone\n" if ($sointernal);
    print STDERR "\t-l milestone\tregister new milestone with database\n" if !($sointernal);
    print STDERR "\t-r\t\tremove solver and module output trees, update milestone information\n" if !($sointernal);
    print STDERR "\t-f\t\tavoid updating entire tree\n" if !($sointernal);
    print STDERR "Notes:\n";
    print STDERR "\tA Milestone on a different MWS can be specified as <MWS:milestone>.\n";
    print STDERR "Examples:\n";
    print STDERR "\tcwsresync -m SRX645:m1 all \n";
    print STDERR "\tcwsresync -c all \n";
    print STDERR "\tcwsresync -l SRX645:m1 \n" if ($sointernal);
    print STDERR "\tcwsresync -r\n" if !($sointernal);
}

# vim: set ts=4 shiftwidth=4 expandtab syntax=perl: