Subversion Repositories DevTools

###############################################################################

# CLASS Clearcase::Cmd

# Base Class for executing clearcase commands and allowing results to be proceesed.

# 

# The class should be instantiated, the Clearcase Command and Arguements set and

# then the CCexecute should be called to execute the command.  By default this 

# class will then simply just print the result to the console if no derived class

# overrides the CCProcess method.

# Dereived Classes should override the CCProcess member, which is called by CCexecute

# after the Clearcase command has been executed, to process the output of the 

# command as required.

#

# By convention all members/methods that begin with an '_' are private.

# 

###############################################################################

package Clearcase::Cmd;

use strict;

use Cwd;

use DeployUtils::Logger;

use IO::File;

use File::Temp qw /mktemp/;

use File::Spec qw /tmpdir/;

#==============================================================================

#   Constructor

#==============================================================================

sub new

{

    my $obclass = shift;

    my $class = ref($obclass) || $obclass;

    LogDebug("ClearCase::Cmd::new Instantiating new object of class $class");

    bless my $self = {

        _CWD             => Cwd::cwd,

        _CLEARTOOL       => ( $^O eq "solaris" ) ? "/usr/atria/bin/cleartool" : "cleartool",

        _CMD             => "",

        _ARGS            => "",

        _TMPNAME         => "",

        _CMDOUTPUT       => new IO::File,

        _PROCESSOUTPUT   => 1,

        _ABORTONERROR    => 1

    } => ( $class );

    return($self);

}   # new

#==============================================================================

#   DESTROY ( Desctructor )

#==============================================================================

sub DESTROY

{

    my $self = shift;

    $self->reset();

}   # DESTROY

#==============================================================================

#   reset

# Closes the filehandle and removes the temp file if any

#==============================================================================

sub reset

{

    my $self = shift;

    $self->{_CMDOUTPUT}->close if ( defined($self->{_CMDOUTPUT}) && defined($self->{_CMDOUTPUT}->fileno()) );

    unlink($self->{_TMPNAME}) if ( $self->{_TMPNAME} ne "" && -f $self->{_TMPNAME} );

}   # reset

###############################################################################

# Set/Get member methods.

# The following functions allow callers to set/get internal members.

###############################################################################

#==============================================================================

#   CCcwd accessor method returns CWD

#==============================================================================

sub CCcwd

{

    my $self = shift;

    return $self->{_CWD};

}   # CCcwd

#==============================================================================

#   CCcmd accessor sets & returns the Clearcase command

#==============================================================================

sub CCcmd

{

    my $self = shift;

    if ( @_ )

    {

        # if we are setting the command then we need to make sure the object is reset in case its a new cmd

        $self->reset();

        $self->{_CMD} = shift;

        $self->{_ARGS} = "";

        LogDebug("ClearCase::Cmd::CCcmd Set CC Command to $self->{_CMD}");

    }

    return $self->{_CMD};

}   # cc_cmd

#==============================================================================

#   CCargs accessor sets & returns the Clearcase command arguements

#==============================================================================

sub CCargs

{

    my $self = shift;

    if ( @_ )

    {

        $self->{_ARGS} = shift;

        LogDebug("ClearCase::Cmd::CCargs Set CC Args to $self->{_ARGS}");

    }

    return $self->{_ARGS};

}   # cc_args

#==============================================================================

#   CCaddArgs accessor appends arsg to existing args list

#==============================================================================

sub CCaddArgs

{

    my $self = shift;

    foreach my $i ( @_ )

    {

        $self->{_ARGS} .= " " . $i;

    }

    LogDebug("ClearCase::Cmd::CCaddArgs Set CC Args to $self->{_ARGS}");

    return $self->{_ARGS};

}   # cc_args

#==============================================================================

#   processOutput

# Sets the processOutput flag to 1 or 0.  If 1 clearcase commands are redirected

# to a file for processing by CCProcess, otherwise 0 does not redirection or processing.

#==============================================================================

sub processOutput

{

    my $self = shift;

    if ( @_ )

    {

        my $val = shift;

        $self->{_PROCESSOUTPUT} = ( $val == 0 ) ? 0 : 1;

        LogDebug("ClearCase::Cmd::processOutput Set to $self->{_PROCESSOUTPUT}");

    }

    return $self->{_PROCESSOUTPUT};

}   # processOutput

#==============================================================================

#   abortOnError

# Sets the abortOnError flag to 1 or 0.  If 0 then CCexecute ignores errors and 

# returns the error code, if 1 then errors are reported & script terminates

#==============================================================================

sub abortOnError

{

    my $self = shift;

    if ( @_ )

    {

        my $val = shift;

        $self->{_ABORTONERROR} = ( $val == 0 ) ? 0 : 1;

        LogDebug("ClearCase::Cmd::abortOnError Set to $self->{_ABORTONERROR}");

    }

    return $self->{_ABORTONERROR};

}   # abortOnError

#==============================================================================

#   CCexecute executes cleartool cmd with args and stores resulting output in

#   IO::File handle in self

#==============================================================================

sub CCexecute

{

    my $self = shift;

    my $retval;

    if ( $self->{_CMD} eq "" )

    {

        LogError("ClearCase::Cmd::CCexecute No Command to execute");

    }

    if ( $self->{_PROCESSOUTPUT} )

    {

        $self->{_TMPNAME} = File::Spec->tmpdir() . "/" . mktemp("CCCmdXXXXX");

        LogDebug("ClearCase::Cmd::CCexecute Executing cmd \"$self->{_CLEARTOOL} $self->{_CMD} $self->{_ARGS} > $self->{_TMPNAME}\".");

        $retval = system("$self->{_CLEARTOOL} $self->{_CMD} $self->{_ARGS} > $self->{_TMPNAME}") >> 8;

    }

    else

    {

        LogDebug("ClearCase::Cmd::CCexecute Executing cmd \"$self->{_CLEARTOOL} $self->{_CMD} $self->{_ARGS}\".");

        $retval = system("$self->{_CLEARTOOL} $self->{_CMD} $self->{_ARGS}") >> 8;

    }

    if ( $retval != 0 )

    {

        unlink($self->{_TMPNAME}) if ( $self->{_TMPNAME} ne "" && -f $self->{_TMPNAME} );

        LogError("ClearCase::Cmd::CCexecute Cmd Execution Failed with error $retval") if ( $self->{_ABORTONERROR} );

        LogError("-x", "ClearCase::Cmd::CCexecute Cmd Execution Failed with error $retval");

    }

    if ( $self->{_PROCESSOUTPUT} )

    {

        $self->{_CMDOUTPUT}->open("<$self->{_TMPNAME}") || LogError("ClearCase::Cmd::CCexecute Cannot open clearcase command results file");

        # Calls processData member to process result.

        # default version in this class simply prints the result to std out.

        $self->CCprocess();

    }

    return $retval;

}   # cc_exec

#==============================================================================

#   CCprocess processes the output from the execute command.

#   This is the default version that just simply dumps the output from the 

#   clearcase command executed to console

#   Any Derived classes can override this and either do nothing or process output 

#   as required.

#   It is a function called by the CCexecute method and should not be

#   called externally

#==============================================================================

sub CCprocess

{

    my $self = shift;

    my $line;

    while ( $line = $self->{_CMDOUTPUT}->getline() )

    {

        print $line;

    }

}   # CCprocess

#==============================================================================

#   getline retunrs the next line from the IO File class using its getline method

#==============================================================================

sub getline

{

    my $self = shift;

    return $self->{_CMDOUTPUT}->getline();

}   # getline

#==============================================================================

#   dumpSelf, debugging member to dump selfs hash

#==============================================================================

sub dumpSelf

{

    use Data::Dumper;

    my $self = shift;

    print Data::Dumper->Dump([$self], [ref($self)]);

}   # dumpSelf

1;