//
// Return true to cancel a long running operation
//
bool pysvn_context::contextCancel()
{
PythonDisallowThreads callback_permission( m_permission );
// make sure we can call the users object
if( !m_pyfn_Cancel.isCallable() )
return false;
Py::Callable callback( m_pyfn_Cancel );
Py::Tuple args( 0 );
// bool
Py::Object result;
Py::Int retcode;
try
{
result = callback.apply( args );
retcode = result;
return long( retcode ) != 0;
}
catch( Py::Exception &e )
{
PyErr_Print();
e.clear();
m_error_message = "unhandled exception in callback_cancel";
return false;
}
}
//
// this method will be called to retrieve
// a log message
//
bool pysvn_context::contextGetLogMessage( std::string & a_msg )
{
if( !m_log_message.empty() )
{
a_msg = m_log_message;
m_log_message.erase();
return true;
}
PythonDisallowThreads callback_permission( m_permission );
if( !m_pyfn_GetLogMessage.isCallable() )
{
m_error_message = "callback_get_log_message required";
return false;
}
Py::Tuple args( 0 );
try
{
return get_string( m_pyfn_GetLogMessage, args, a_msg );
}
catch( Py::Exception &e )
{
PyErr_Print();
e.clear();
m_error_message = "unhandled exception in callback_get_log_message";
}
return false;
}
void pysvn_context::contextProgress
(
apr_off_t progress,
apr_off_t total
)
{
PythonDisallowThreads callback_permission( m_permission );
// make sure we can call the users object
if( !m_pyfn_Progress.isCallable() )
return;
Py::Callable callback( m_pyfn_Progress );
Py::Tuple args( 2 );
// on some platforms apr_off_t is int64
args[0] = Py::Int( static_cast<long int>( progress ) );
args[1] = Py::Int( static_cast<long int>( total ) );
Py::Object results;
try
{
results = callback.apply( args );
}
catch( Py::Exception &e )
{
PyErr_Print();
e.clear();
m_error_message = "unhandled exception in callback_progress";
}
}
svn_error_t *changelistReceiver
(
void *baton_,
const char *path,
const char *changelist,
apr_pool_t *pool
)
{
ChangelistBaton *baton = reinterpret_cast<ChangelistBaton *>( baton_ );
PythonDisallowThreads callback_permission( baton->m_permission );
if( path == NULL || changelist == NULL )
{
return NULL;
}
Py::Tuple values( 2 );
values[0] = Py::String( path );
values[1] = Py::String( changelist );
baton->m_changelist_list.append( values );
return NULL;
}
static svn_error_t *info_receiver_c( void *baton_, const char *path, const svn_info_t *info, apr_pool_t *pool )
{
InfoReceiveBaton *baton = reinterpret_cast<InfoReceiveBaton *>( baton_ );
PythonDisallowThreads callback_permission( baton->m_permission );
if( path != NULL )
{
std::string std_path( path );
if( std_path.empty() )
{
std_path = ".";
}
Py::String py_path( std_path );
Py::Tuple py_pair( 2 );
py_pair[0] = py_path;
py_pair[1] = toObject(
*info,
baton->m_wrapper_info,
baton->m_wrapper_lock,
baton->m_wrapper_wc_info );
baton->m_info_list.append( py_pair );
}
return SVN_NO_ERROR;
}
//
// this method is called to retrieve the password
// for the certificate
//
// @param password
//
bool pysvn_context::contextSslClientCertPwPrompt
(
std::string &_password,
const std::string &_realm,
bool &_may_save
)
{
PythonDisallowThreads callback_permission( m_permission );
// make sure we can call the users object
if( !m_pyfn_SslClientCertPwPrompt.isCallable() )
{
m_error_message = "callback_ssl_client_cert_password_prompt required";
return false;
}
Py::Callable callback( m_pyfn_SslClientCertPwPrompt );
Py::Tuple args( 2 );
args[0] = Py::String( _realm );
args[1] = Py::Int( (long)_may_save );
// bool, username, password
Py::Tuple results;
Py::Int retcode;
Py::String username;
Py::String password;
Py::Int may_save_out;
try
{
results = callback.apply( args );
retcode = results[0];
password = results[1];
may_save_out = results[2];
// true returned
if( long( retcode ) != 0 )
{
// copy out the answers
_password = password.as_std_string();
_may_save = long( may_save_out ) != 0;
return true;
}
}
catch( Py::Exception &e )
{
PyErr_Print();
e.clear();
m_error_message = "unhandled exception in callback_ssl_client_cert_password_prompt";
return false;
}
return false;
}
void pysvn_context::contextNotify2
(
const svn_wc_notify_t *notify,
apr_pool_t *pool
)
{
PythonDisallowThreads callback_permission( m_permission );
// make sure we can call the users object
if( !m_pyfn_Notify.isCallable() )
return;
Py::Callable callback( m_pyfn_Notify );
Py::Tuple args( 1 );
Py::Dict info;
args[0] = info;
info["path"] = Py::String( notify->path );
info["action"] = toEnumValue( notify->action );
info["kind"] = toEnumValue( notify->kind );
if( notify->mime_type == NULL )
info["mime_type"] = Py::Nothing();
else
info["mime_type"] = Py::String( notify->mime_type );
info["content_state"] = toEnumValue( notify->content_state );
info["prop_state"] = toEnumValue( notify->prop_state );
info["revision"] = Py::asObject( new pysvn_revision( svn_opt_revision_number, 0, notify->revision ) );
if( notify->err != NULL )
{
SvnException error( notify->err );
info["error"] = error.pythonExceptionArg( 1 );
}
else
{
info["error"] = Py::None();
}
Py::Object results;
try
{
results = callback.apply( args );
}
catch( Py::Exception &e )
{
PyErr_Print();
e.clear();
m_error_message = "unhandled exception in callback_notify";
}
}
//
// this method is called to retrieve client side
// information
//
bool pysvn_context::contextSslClientCertPrompt( std::string &_cert_file, const std::string &_realm, bool &_may_save )
{
PythonDisallowThreads callback_permission( m_permission );
if( !m_pyfn_SslClientCertPrompt.isCallable() )
{
m_error_message = "callback_ssl_client_cert_prompt required";
return false;
}
Py::Callable callback( m_pyfn_SslClientCertPrompt );
Py::Tuple args( 2 );
args[0] = Py::String( _realm );
args[1] = Py::Int( _may_save );
Py::Tuple results;
Py::Int retcode;
Py::String cert_file;
Py::Int may_save_out;
try
{
results = callback.apply( args );
retcode = results[0];
cert_file = results[1];
may_save_out = results[2];
if( long( retcode ) != 0 )
{
_cert_file = cert_file.as_std_string();
_may_save = long( may_save_out ) != 0;
return true;
}
}
catch( Py::Exception &e )
{
PyErr_Print();
e.clear();
m_error_message = "unhandled exception in callback_ssl_client_cert_prompt";
return false;
}
return false;
}
void pysvn_context::contextNotify
(
const char *path,
svn_wc_notify_action_t action,
svn_node_kind_t kind,
const char *mime_type,
svn_wc_notify_state_t content_state,
svn_wc_notify_state_t prop_state,
svn_revnum_t revnum
)
{
PythonDisallowThreads callback_permission( m_permission );
// make sure we can call the users object
if( !m_pyfn_Notify.isCallable() )
return;
Py::Callable callback( m_pyfn_Notify );
Py::Tuple args( 1 );
Py::Dict info;
args[0] = info;
info["path"] = Py::String( path );
info["action"] = toEnumValue( action );
info["kind"] = toEnumValue( kind );
if( mime_type == NULL )
info["mime_type"] = Py::Nothing();
else
info["mime_type"] = Py::String( mime_type );
info["content_state"] = toEnumValue( content_state );
info["prop_state"] = toEnumValue( prop_state );
info["revision"] = Py::asObject( new pysvn_revision( svn_opt_revision_number, 0, revnum ) );
Py::Object results;
try
{
results = callback.apply( args );
}
catch( Py::Exception &e )
{
PyErr_Print();
e.clear();
m_error_message = "unhandled exception in callback_notify";
}
}
svn_error_t *proplist_receiver_c
(
void *baton_,
const char *path,
apr_hash_t *prop_hash,
apr_pool_t *pool
)
{
ProplistReceiveBaton *baton = reinterpret_cast<ProplistReceiveBaton *>( baton_ );
PythonDisallowThreads callback_permission( baton->m_permission );
Py::Dict prop_dict;
Py::Tuple py_tuple( 2 );
py_tuple[0] = Py::String( path );
py_tuple[1] = propsToObject( prop_hash, baton->m_pool );
baton->m_prop_list.append( py_tuple );
return SVN_NO_ERROR;
}
svn_error_t *diff_summarize_c
(
const svn_client_diff_summarize_t *diff,
void *baton_,
apr_pool_t *pool
)
{
DiffSummarizeBaton *baton = reinterpret_cast<DiffSummarizeBaton *>( baton_ );
PythonDisallowThreads callback_permission( baton->m_permission );
Py::Dict diff_dict;
diff_dict[ *py_name_path ] = Py::String( diff->path, name_utf8 );
diff_dict[ *py_name_summarize_kind ] = toEnumValue( diff->summarize_kind );
diff_dict[ *py_name_prop_changed ] = Py::Int( diff->prop_changed != 0 );
diff_dict[ *py_name_node_kind ] = toEnumValue( diff->node_kind );
baton->m_diff_list.append( baton->m_wrapper_diff_summary->wrapDict( diff_dict ) );
return SVN_NO_ERROR;
}
svn_error_t *list_receiver_c
(
void *baton_,
const char *path,
const svn_dirent_t *dirent,
const svn_lock_t *lock,
const char *abs_path,
apr_pool_t *pool
)
{
ListReceiveBaton *baton = reinterpret_cast<ListReceiveBaton *>( baton_ );
PythonDisallowThreads callback_permission( baton->m_permission );
std::string full_path( baton->m_url_or_path );
std::string full_repos_path( abs_path );
if( strlen( path ) != 0 )
{
full_path += "/";
full_path += path;
full_repos_path += "/";
full_repos_path += path;
}
Py::Tuple py_tuple( 2 );
Py::Dict entry_dict;
entry_dict[ *py_name_path ] = Py::String( full_path, name_utf8 );
entry_dict[ *py_name_repos_path ] = Py::String( full_repos_path, name_utf8 );
if( dirent != NULL )
{
if( baton->m_dirent_fields&SVN_DIRENT_KIND )
{
entry_dict[ *py_name_kind ] = toEnumValue( dirent->kind );
}
if( baton->m_dirent_fields&SVN_DIRENT_SIZE )
{
entry_dict[ *py_name_size ] = Py::Long( Py::Float( double( static_cast<signed_int64>( dirent->size ) ) ) );
}
if( baton->m_dirent_fields&SVN_DIRENT_CREATED_REV )
{
entry_dict[ *py_name_created_rev ] = Py::asObject( new pysvn_revision( svn_opt_revision_number, 0, dirent->created_rev ) );
}
if( baton->m_dirent_fields&SVN_DIRENT_TIME )
{
entry_dict[ *py_name_time ] = toObject( dirent->time );
}
if( baton->m_dirent_fields&SVN_DIRENT_HAS_PROPS )
{
entry_dict[ *py_name_has_props ] = Py::Int( dirent->has_props );
}
if( baton->m_dirent_fields&SVN_DIRENT_LAST_AUTHOR )
{
entry_dict[ *py_name_last_author ] = utf8_string_or_none( dirent->last_author );
}
}
py_tuple[0] = baton->m_wrapper_list->wrapDict( entry_dict );
if( lock == NULL )
{
py_tuple[1] = Py::None();
}
else
{
py_tuple[1] = toObject( *lock, *baton->m_wrapper_lock );
}
baton->m_list_list.append( py_tuple );
return SVN_NO_ERROR;
}
//
// this method is called if there is ssl server
// information, that has to be confirmed by the user
//
// @param data
// @return @a SslServerTrustAnswer
//
bool pysvn_context::contextSslServerTrustPrompt
(
const svn_auth_ssl_server_cert_info_t &info,
const std::string &realm,
apr_uint32_t &a_accepted_failures,
bool &accept_permanent
)
{
PythonDisallowThreads callback_permission( m_permission );
// make sure we can call the users object
if( !m_pyfn_SslServerTrustPrompt.isCallable() )
{
m_error_message = "callback_ssl_server_trust_prompt required";
return false;
}
Py::Callable callback( m_pyfn_SslServerTrustPrompt );
Py::Dict trust_info;
trust_info[Py::String("failures")] = Py::Int( long( a_accepted_failures ) );
trust_info[Py::String("hostname")] = Py::String( info.hostname );
trust_info[Py::String("finger_print")] = Py::String( info.fingerprint );
trust_info[Py::String("valid_from")] = Py::String( info.valid_from );
trust_info[Py::String("valid_until")] = Py::String( info.valid_until );
trust_info[Py::String("issuer_dname")] = Py::String( info.issuer_dname );
trust_info[Py::String("realm")] = Py::String( realm );
Py::Tuple args( 1 );
args[0] = trust_info;
Py::Tuple result_tuple;
Py::Int retcode;
Py::Int accepted_failures;
Py::Int may_save;
try
{
result_tuple = callback.apply( args );
retcode = result_tuple[0];
accepted_failures = result_tuple[1];
may_save = result_tuple[2];
a_accepted_failures = long( accepted_failures );
if( long( retcode ) != 0 )
{
accept_permanent = long( may_save ) != 0;
return true;
}
else
return false;
}
catch( Py::Exception &e )
{
PyErr_Print();
e.clear();
m_error_message = "unhandled exception in callback_ssl_server_trust_prompt";
}
return false;
}
static svn_error_t *log4Receiver
(
void *baton_,
svn_log_entry_t *log_entry,
apr_pool_t *pool
)
{
Log4Baton *baton = reinterpret_cast<Log4Baton *>( baton_ );
if( log_entry->revision == 0 )
{
// skip this blank entry
// as the svn log command does
return NULL;
}
PythonDisallowThreads callback_permission( baton->m_permission );
Py::Dict entry_dict;
Py::Object revprops;
if( log_entry->revprops == NULL )
{
revprops = Py::None();
}
else
{
revprops = propsToObject( log_entry->revprops, baton->m_pool );
Py::Dict revprops_dict;
revprops_dict = revprops;
if( revprops_dict.hasKey( "svn:date" ) )
{
Py::String date( revprops_dict[ "svn:date" ] );
Py::Object int_date = toObject( convertStringToTime( date.as_std_string( g_utf_8 ), baton->m_now, baton->m_pool ) );
revprops_dict[ "svn:date" ] = int_date;
entry_dict[ name_date ] = int_date;
}
if( revprops_dict.hasKey( "svn:author" ) )
{
entry_dict[ name_author ] = revprops_dict[ "svn:author" ];
}
if( revprops_dict.hasKey( "svn:log" ) )
{
Py::String message( revprops_dict[ "svn:log" ] );
revprops_dict[ "svn:log" ] = message;
entry_dict[ name_message ] = message;
}
}
entry_dict[ name_revprops ] = revprops;
entry_dict[ name_revision ] = Py::asObject( new pysvn_revision( svn_opt_revision_number, 0, log_entry->revision ) );
Py::List changed_paths_list;
#if defined( PYSVN_HAS_CLIENT_LOG5 )
if( log_entry->changed_paths2 != NULL )
{
for( apr_hash_index_t *hi = apr_hash_first( pool, log_entry->changed_paths2 );
hi != NULL;
hi = apr_hash_next( hi ) )
{
Py::Dict changed_entry_dict;
char *path = NULL;
void *val = NULL;
apr_hash_this( hi, (const void **) &path, NULL, &val );
svn_log_changed_path_t *log_item = reinterpret_cast<svn_log_changed_path_t *> (val);
changed_entry_dict[ name_path ] = Py::String( path );
char action[2]; action[0] = log_item->action; action[1] = 0;
changed_entry_dict[ name_action ] = Py::String( action );
changed_entry_dict[ name_copyfrom_path ] = utf8_string_or_none( log_item->copyfrom_path );
if( SVN_IS_VALID_REVNUM( log_item->copyfrom_rev ) )
changed_entry_dict[ name_copyfrom_revision ] =
Py::asObject( new pysvn_revision( svn_opt_revision_number, 0, log_item->copyfrom_rev ) );
else
changed_entry_dict[ name_copyfrom_revision ] = Py::None();
changed_paths_list.append( baton->m_wrapper_log_changed_path->wrapDict( changed_entry_dict ) );
}
}
#else
if( log_entry->changed_paths != NULL )
{
for( apr_hash_index_t *hi = apr_hash_first( pool, log_entry->changed_paths );
hi != NULL;
hi = apr_hash_next( hi ) )
{
Py::Dict changed_entry_dict;
char *path = NULL;
void *val = NULL;
apr_hash_this( hi, (const void **) &path, NULL, &val );
svn_log_changed_path_t *log_item = reinterpret_cast<svn_log_changed_path_t *> (val);
changed_entry_dict[ name_path ] = Py::String( path );
char action[2]; action[0] = log_item->action; action[1] = 0;
changed_entry_dict[ name_action ] = Py::String( action );
changed_entry_dict[ name_copyfrom_path ] = utf8_string_or_none( log_item->copyfrom_path );
if( SVN_IS_VALID_REVNUM( log_item->copyfrom_rev ) )
changed_entry_dict[ name_copyfrom_revision ] =
Py::asObject( new pysvn_revision( svn_opt_revision_number, 0, log_item->copyfrom_rev ) );
else
changed_entry_dict[ name_copyfrom_revision ] = Py::None();
changed_paths_list.append( baton->m_wrapper_log_changed_path->wrapDict( changed_entry_dict ) );
}
}
#endif
entry_dict[ name_changed_paths ] = changed_paths_list;
entry_dict[ "has_children" ] = Py::Int( log_entry->has_children != 0 ? 1 : 0 );
baton->m_log_list.append( baton->m_wrapper_log->wrapDict( entry_dict ) );
return NULL;
}
