p4clientapi.cpp #20

/*******************************************************************************

Copyright (c) 1997-2004, Perforce Software, Inc.  All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

1.  Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.

2.  Redistributions in binary form must reproduce the above copyright
    notice, this list of conditions and the following disclaimer in the
    documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTR
IBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL PERFORCE SOFTWARE, INC. BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*******************************************************************************/

/*******************************************************************************
 * Name		: p4clientapi.cc
 *
 * Author	: Tony Smith <tony@perforce.com> or <tony@smee.org>
 *
 * Description	: Ruby bindings for the Perforce API. Main interface to the
 * 		  Perforce API.
 *
 ******************************************************************************/
#include <ruby.h>
#include "undefdups.h"
#include <clientapi.h>
#include <i18napi.h>
#include <strtable.h>
#include <spec.h>
#include "extconf.h"
#include "debug.h"
#include "p4result.h"
#include "p4rubydebug.h"
#include "clientuserruby.h"
#include "specmgr.h"
#include "p4clientapi.h"



/*******************************************************************************
 * Our Ruby classes.
 ******************************************************************************/
extern VALUE 	cP4;	// Base P4 class
extern VALUE 	eP4;	// Exception class

#define		M_TAGGED		0x01
#define		M_PARSE_FORMS		0x02
#define		IS_TAGGED(x)		(x & M_TAGGED )
#define		IS_PARSE_FORMS(x)	(x & M_PARSE_FORMS )


P4ClientApi::P4ClientApi()
{
    initCount = 0;
    debug = 0;
    server2 = 0;
    mode = 0;
    depth = 0;
    exceptionLevel = 2;
    maxResults = 0;
    maxScanRows = 0;
    prog = "unnamed p4ruby script";
}

P4ClientApi::~P4ClientApi()
{
    if ( initCount )
    {
	Error e;
	client.Final( &e );
	// Ignore errors
    }
}

int
P4ClientApi::SetCharset( const char *c )
{
    if( P4RDB_COMMANDS )
	fprintf( stderr, "[P4] Setting charset: %s\n", c );

    CharSetApi::CharSet cs = CharSetApi::Lookup( c );
    if( cs < 0 )
    {
	if( exceptionLevel )
	{
	    StrBuf	m;
	    m = "Unknown or unsupported charset: ";
	    m.Append( c );
	    Except( "P4#charset=", m.Text() );
	}
	return 0;
    }
    charset = c;
    client.SetTrans( cs, cs, cs, cs );
    return 1;
}
    

void
P4ClientApi::SetProg( const char *p )
{
    prog = p;
}

void 
P4ClientApi::SetDebug( int d )
{
    debug = d;
    ui.SetDebug( d );
    if( P4RDB_RPC )
	p4debug.SetLevel( "rpc=5" );
    else
	p4debug.SetLevel( "rpc=0" );
}

//
// connect to the Perforce server.
//

VALUE 
P4ClientApi::Connect()
{
    if ( P4RDB_COMMANDS )
	fprintf( stderr, "[P4] Connecting to Perforce\n" );

    if ( initCount )
    {
	rb_warn( "P4#connect - Perforce client already connected!" );
	return Qtrue;
    }

    Error	e;

    specDict.Clear();	// Don't cache specs across connections

    client.Init( &e );
    if ( e.Test() && exceptionLevel )
	Except( "P4#connect", &e );

    if ( e.Test() )
	return Qfalse;

    initCount++;
    return Qtrue;
}


//
// Disconnect session
//
VALUE 
P4ClientApi::Disconnect()
{
    if ( P4RDB_COMMANDS )
	fprintf( stderr, "[P4] Disconnect\n" );

    if ( ! initCount )
    {
	rb_warn( "P4#disconnect - not connected" );
	return Qtrue;
    }
    Error	e;
    client.Final( &e );

    initCount--;
    return Qtrue;
}

void 
P4ClientApi::Tagged( int enable )
{
    if( enable )
	mode |= M_TAGGED;
    else
	mode &= ~M_TAGGED;
}

void 
P4ClientApi::ParseForms()
{
    client.SetProtocol( "specstring", "" );
    mode |= M_PARSE_FORMS + M_TAGGED ;
}

void 
P4ClientApi::SetApiLevel( int level )
{
    StrBuf	b;
    b << level;
    client.SetProtocol( "api", b.Text() );
}

//
// Run returns the results of the command. If the client has not been
// connected, then an exception is raised but errors from Perforce
// commands are returned via the Errors() and ErrorCount() interfaces
// and not via exceptions because one failure in a command applied to many
// files would interrupt processing of all the other files if an exception
// is raised.
//

VALUE 
P4ClientApi::Run( const char *cmd, int argc, char * const *argv )
{
    // Save the entire command string for our error messages. Makes it
    // easy to see where a script has gone wrong.
    StrBuf	cmdString;
    cmdString << "\"p4 " << cmd;
    for( int i = 0; i < argc; i++ )
        cmdString << " " << argv[ i ];
    cmdString << "\"";

    if ( P4RDB_COMMANDS )
	fprintf( stderr, "[P4] Executing %s\n", cmdString.Text()  );

    if ( depth )
    {
	rb_warn( "Can't execute nested Perforce commands." );
	return Qfalse;
    }

    if ( ! initCount && exceptionLevel )
	Except( "P4#run", "not connected." );

    if ( ! initCount )
	return Qfalse;

#if P4APIVER_ID >= 513026
    // ClientApi::SetProg() was introduced in 2004.2
    client.SetProg( prog.Text() );
#endif

    if( mode & M_TAGGED )
	client.SetVar( "tag" );

    // Clear out any results from the previous command
    ui.Reset();

    depth++;
    RunCmd( cmd, &ui, argc, argv );
    depth--;

    P4Result &results = ui.GetResults();

    if( ui.LastSpecDef().Length() )
	specDict.SetVar( cmd, ui.LastSpecDef() );

    if ( results.ErrorCount() && exceptionLevel )
	Except( "P4#run", "Errors during command execution", cmdString.Text() );

    if ( results.WarningCount() && exceptionLevel > 1 )
	Except( "P4#run", "Warnings during command execution",cmdString.Text());

    return results.GetOutput();
}


//
// RunCmd is a private function to work around an obscure protocol
// bug in 2000.[12] servers. Running a "p4 -Ztag client -o" messes up the
// protocol so if they're running this command then we disconnect and
// reconnect to refresh it. For efficiency, we only do this if the 
// server2 protocol is either 9 or 10 as other versions aren't affected.
//
void
P4ClientApi::RunCmd( const char *cmd, ClientUser *ui, int argc, char * const *argv )
{
    // If maxresults or maxscanrows is set, enforce them now
    if( maxResults  )	client.SetVar( "maxResults",  maxResults  );
    if( maxScanRows )	client.SetVar( "maxScanRows", maxScanRows );

    client.SetArgv( argc, argv );
    client.Run( cmd, ui );

    // Have to request server2 protocol *after* a command has been run. I
    // don't know why, but that's the way it is.

    if ( ! server2 )
    {
	StrPtr *pv = client.GetProtocol( "server2" );
	if ( pv )
	    server2 = pv->Atoi();
    }

    if ( IS_TAGGED(mode) && StrRef( cmd ) == "client" && 
	 server2 >= 9    && server2 <= 10  )
    {
	if ( argc && ( StrRef( argv[ 0 ] ) == "-o" ) )
	{
	    if ( P4RDB_COMMANDS )
		printf( "Resetting client to avoid 2000.[12] protocol bug\n" );

	    Error e;
	    client.Final( &e );
	    client.Init( &e );

	    // Pass any errors down to the UI, so they'll get picked up.
	    if ( e.Test() ) 
		ui->HandleError( &e );
	}
    }
}


//
// Parses a string supplied by the user into a hash. To do this we need
// the specstring from the server. We try to cache those as we see them, 
// but the user may not have executed any commands to allow us to cache
// them so we may have to fetch the spec first.
//

VALUE
P4ClientApi::ParseSpec( const char * type, const char *form )
{
    if( ! IS_PARSE_FORMS(mode) )
    {
	if( exceptionLevel )
	    Except( "P4#parse_spec", "Use parse_forms mode to parse specs." );
	return Qfalse;
    }

    StrPtr	*specDef = FetchSpecDef( type );

    if ( !specDef )
    {
	if( exceptionLevel )
	{
	    StrBuf m;
	    m = "No spec definition for ";
	    m.Append( type );
	    m.Append( " objects." );
	    Except( "P4#parse_spec", m.Text() );
	}
	else
	{
	    return Qfalse;
	}
    }

    // Got a specdef so now we can attempt to parse it.
    
    Error		e;
    SpecDataTable	specData;
#if P4APIVER_ID >= 513538
    Spec		s( specDef->Text(), "", &e );
#else
    Spec		s( specDef->Text(), "" );
#endif
    SpecMgr		m;

    if( !e.Test() ) s.ParseNoValid( form, &specData, &e );
    if ( e.Test() )
    {
	if( exceptionLevel )
	{
	    Except( "P4#parse_spec", &e );
	}
	else
	{
	    return Qfalse;
	}
    }

    // Now we've parsed it, convert it into a P4::Spec object. 

    return m.DictToSpec( specData.Dict(), specDef );
}
    

//
// Converts a hash supplied by the user into a string using the specstring
// from the server. We may have to fetch the specstring first.
//

VALUE
P4ClientApi::FormatSpec( const char * type, VALUE hash )
{
    if( ! IS_PARSE_FORMS(mode) )
    {
	if( exceptionLevel )
	    Except( "P4#format_spec", "Use parse_forms mode to format specs." );
	return Qfalse;
    }

    StrPtr	*specDef = FetchSpecDef( type );
    Error	e;

    if ( !specDef )
    {
	if( exceptionLevel )
	{
	    StrBuf m;
	    m = "No spec definition for ";
	    m.Append( type );
	    m.Append( " objects." );
	    Except( "P4#format_spec", m.Text() );
	}
	else
	{
	    return Qfalse;
	}
    }

    // Got a specdef so now we can attempt to convert. 
    StrBuf	buf;
    SpecMgr	m;

    if( m.HashToText( hash, &buf, specDef, &e ) )
	return rb_str_new2( buf.Text() );
    
    if( exceptionLevel )
    {
	StrBuf m;
	m = "Error converting hash to a string.";
	if( e.Test() ) e.Fmt( m, EF_PLAIN );
	Except( "P4#format_spec", m.Text() );
    }
    return Qnil;
}

//
// Returns a hash whose keys contain the names of the fields in a spec of the
// specified type. Not yet exposed to Ruby clients, but may be in future.
//
VALUE
P4ClientApi::SpecFields( const char * type )
{
    if( ! IS_PARSE_FORMS(mode) )
    {
	if( exceptionLevel )
	    Except( "P4#spec_fields", "Use parse_forms mode to work with specs." );
	return Qfalse;
    }

    StrPtr	*specDef = FetchSpecDef( type );

    if ( !specDef )
    {
	if( exceptionLevel )
	{
	    StrBuf m;
	    m = "No spec definition for ";
	    m.Append( type );
	    m.Append( " objects." );
	    Except( "P4#spec_fields", m.Text() );
	}
	else
	{
	    return Qfalse;
	}
    }

    SpecMgr m;
    return m.SpecFields( specDef );
}
    
//
// Raises an exception or returns Qfalse on bad input
//

VALUE
P4ClientApi::SetInput( VALUE input )
{
    if ( P4RDB_COMMANDS )
	fprintf( stderr, "[P4] Received input for next command\n" );

    if ( ! ui.SetInput( input ) )
    {
	if ( exceptionLevel )
	    Except( "P4#input", "Error parsing supplied data." );
    	else
	    return Qfalse;
    }
    return Qtrue;
}

void
P4ClientApi::GCMark()
{
    if ( P4RDB_GC )
	fprintf( stderr, "[P4] Ruby asked us to do garbage collection\n" );

    // We don't hold Ruby objects. But our UI does.
    ui.GCMark();
}

void
P4ClientApi::Except( const char *func, const char *msg )
{
    StrBuf	m;
    StrBuf	errors;
    StrBuf	warnings;
    int		terminate = 0;
    
    m << "[" << func << "] " << msg;

    // Now append any errors and warnings to the text
    ui.GetResults().FmtErrors( errors );
    ui.GetResults().FmtWarnings( warnings );
    
    if( errors.Length() )
    {
	m << "\n" << errors;
	terminate++;
    }

    if( exceptionLevel > 1 && warnings.Length() )
    {
	m << "\n" << warnings;
	terminate++;
    }

    if( terminate )
	m << "\n\n";

    rb_raise( eP4, m.Text() );
}

void
P4ClientApi::Except( const char *func, const char *msg, const char *cmd )
{
    StrBuf m;

    m << msg;
    m << "( " << cmd << " )";
    Except( func, m.Text() );
}

void
P4ClientApi::Except( const char *func, Error *e )
{
    StrBuf	m;

    e->Fmt( &m );
    Except( func, m.Text() );
}


//
// Fetch a spec definition from the cache - faulting it if it's not there.
//

StrPtr * 
P4ClientApi::FetchSpecDef( const char *type )
{
    StrPtr *sd = specDict.GetVar( type );
    if( sd ) return sd;

    // Fault. Now we have to do something nasty. We're in parse_forms mode, so 
    // we can run a "p4 XXXX -o" and discard the result - the specdef should 
    // now be in the cache.  Some spec types require us to name the spec in
    // question. Since we don't know, we use a bogus name. We include the
    // word p4ruby in it so people know where to look if they spot it in
    // their logs.

    char *	bogusSpec = "__p4ruby_bogus_spec__";

    char * 	argv[3] = { "-o", 0, 0 };
    int		argc = 1;
    
    // 
    // For specs of the following types we need the bogus spec name
    //
    StrRef t( type );

    if( t == "branch" || t == "label" || t == "depot" || t == "group" )
	argv[ argc++ ] = bogusSpec;

    Run( type, argc, argv );

    sd = specDict.GetVar( type );
    if( sd ) return sd;

    // OK, now we're hosed. Raise an exception if the exception level permits,
    // otherwise return null

    if( exceptionLevel )
	Except( "P4#FetchSpecDef", "Error getting spec definition from server!" );

    return 0;
}