예제 #1
0
  /**
   * lists properties in @a path no matter whether local or
   * repository
   *
   * @param path
   * @param revision
   * @param recurse
   * @return PropertiesList
   */
  PathPropertiesMapList
  Client::proplist(const Path & path,
                   const Revision & revision,
                   bool recurse)
  {
    Pool pool;
    apr_array_header_t * props;

    svn_error_t * error =
      svn_client_proplist(&props,
                          path.c_str(),
                          revision.revision(),
                          recurse,
                          *m_context,
                          pool);
    if (error != nullptr)
    {
      throw ClientException(error);
    }

    PathPropertiesMapList path_prop_map_list;
    for (int j = 0; j < props->nelts; ++j)
    {
      svn_client_proplist_item_t *item =
        ((svn_client_proplist_item_t **)props->elts)[j];

      PropertiesMap prop_map;

      apr_hash_index_t *hi;
      for (hi = apr_hash_first(pool, item->prop_hash); hi;
           hi = apr_hash_next(hi))
      {
        const void *key;
        void *val;

        apr_hash_this(hi, &key, nullptr, &val);

        prop_map [std::string((const char *)key)] =
          std::string(((const svn_string_t *)val)->data);
      }

      path_prop_map_list.push_back(PathPropertiesMapEntry(item->node_name->data, prop_map));
    }

    return path_prop_map_list;
  }
예제 #2
0
  void
  Property::list()
  {
    Pool pool;
    Revision revision;

    m_entries.clear();
    apr_array_header_t * props;
    svn_error_t * error =
      svn_client_proplist(&props,
                          m_path.c_str(),
                          revision,
                          false, /* recurse */
                          *m_context,
                          pool);
    if (error != NULL)
    {
      throw ClientException(error);
    }

    for (int j = 0; j < props->nelts; ++j)
    {
      svn_client_proplist_item_t *item =
        ((svn_client_proplist_item_t **)props->elts)[j];

      apr_hash_index_t *hi;

      for (hi = apr_hash_first(pool, item->prop_hash); hi;
           hi = apr_hash_next(hi))
      {
        const void *key;
        void *val;

        apr_hash_this(hi, &key, NULL, &val);

        m_entries.push_back(PropertyEntry(
                              (const char *)key, getValue((const char *)key).c_str()));
      }
    }
  }
예제 #3
0
Py::Object pysvn_client::cmd_proplist( const Py::Tuple &a_args, const Py::Dict &a_kws )
{
    static argument_description args_desc[] =
    {
        { true,  name_url_or_path },
        { false, name_revision },
        { false, name_recurse },
#if defined( PYSVN_HAS_CLIENT_PROPLIST2 )
        { false, name_peg_revision },
#endif
#if defined( PYSVN_HAS_CLIENT_PROPLIST3 )
        { false, name_depth },
        { false, name_changelists },
#endif
        { false, NULL }
    };
    FunctionArguments args( "proplist", args_desc, a_args, a_kws );
    args.check();

    Py::List path_list( toListOfStrings( args.getArg( name_url_or_path ) ) );

    SvnPool pool( m_context );

#if defined( PYSVN_HAS_CLIENT_PROPLIST3 )
    apr_array_header_t *changelists = NULL;

    if( args.hasArg( name_changelists ) )
    {
        changelists = arrayOfStringsFromListOfStrings( args.getArg( name_changelists ), pool );
    }

    svn_depth_t depth = args.getDepth( name_depth, name_recurse, svn_depth_files, svn_depth_empty );
#else
    bool recurse = args.getBoolean( name_recurse, false );
#endif
    bool is_revision_setup = false;
    bool is_url = false;

    svn_opt_revision_t revision_url;
    svn_opt_revision_t revision_file;
    if( args.hasArg( name_revision ) )
    {
        revision_url = args.getRevision( name_revision );
        revision_file = revision_url;
    }
    else
    {
        revision_url.kind = svn_opt_revision_head;
        revision_file.kind = svn_opt_revision_working;
    }

#if defined( PYSVN_HAS_CLIENT_PROPLIST2 )
    svn_opt_revision_t peg_revision_url;
    svn_opt_revision_t peg_revision_file;
    if( args.hasArg( name_peg_revision ) )
    {
        peg_revision_url = args.getRevision( name_peg_revision );
        peg_revision_file = peg_revision_url;
    }
    else
    {
        peg_revision_url = revision_url;
        peg_revision_file = revision_file;
    }
#endif

    Py::List list_of_proplists;

    for( Py::List::size_type i=0; i<path_list.length(); i++ )
    {
        Py::String path_str( asUtf8String( path_list[i] ) );
        std::string path( path_str.as_std_string() );
        std::string norm_path( svnNormalisedIfPath( path, pool ) );

        svn_opt_revision_t revision;
        svn_opt_revision_t peg_revision;
        if( !is_revision_setup )
            if( is_svn_url( path ) )
            {
                revision = revision_url;
#if defined( PYSVN_HAS_CLIENT_PROPLIST2 )
                peg_revision = peg_revision_url;
#endif
                is_url = true;
            }
            else
            {
                revision = revision_file;
#if defined( PYSVN_HAS_CLIENT_PROPLIST2 )
                peg_revision = peg_revision_file;
#endif
            }
        else if( is_svn_url( path ) && !is_url )
        {
            throw Py::AttributeError( "cannot mix URL and PATH in name_path" );
        }

        try
        {
            const char *norm_path_c_str= norm_path.c_str();
            checkThreadPermission();

            PythonAllowThreads permission( m_context );

#if defined( PYSVN_HAS_CLIENT_PROPLIST3 )
            ProplistReceiveBaton proplist_baton( &permission, pool, list_of_proplists );
            svn_error_t *error = svn_client_proplist3
                                 (
                                     norm_path_c_str,
                                     &peg_revision,
                                     &revision,
                                     depth,
                                     changelists,
                                     proplist_receiver_c,
                                     reinterpret_cast<void *>( &proplist_baton ),
                                     m_context,
                                     pool
                                 );
#elif defined( PYSVN_HAS_CLIENT_PROPLIST2 )
            apr_array_header_t *props = NULL;
            svn_error_t *error = svn_client_proplist2
                                 (
                                     &props,
                                     norm_path_c_str,
                                     &peg_revision,
                                     &revision,
                                     recurse,
                                     m_context,
                                     pool
                                 );
#else
            apr_array_header_t *props = NULL;
            svn_error_t *error = svn_client_proplist
                                 (
                                     &props,
                                     norm_path_c_str,
                                     &revision,
                                     recurse,
                                     m_context,
                                     pool
                                 );
#endif
            permission.allowThisThread();
            if( error != NULL )
                throw SvnException( error );

#if !defined( PYSVN_HAS_CLIENT_PROPLIST3 )
            proplistToObject( list_of_proplists, props, pool );
#endif
        }
        catch( SvnException &e )
        {
            // use callback error over ClientException
            m_context.checkForError( m_module.client_error );

            throw_client_error( e );
        }
    }

    return list_of_proplists;
}
예제 #4
0
int main( int argc, char **argv )
{
    if( argc < 4 )
    {
        std::cout << "Usage: " << argv[0] << " <path-to-wc-file> <num-calls> <recurse>" << std::endl;
        std::cout << "       " << argv[0] << " readme.txt 50 0" << std::endl;
        std::cout << "       " << argv[0] << " ../Sources 1 1" << std::endl;
        return 1;
    }
    apr_initialize();
    apr_pool_initialize();

    apr_pool_t *m_pool;

    apr_pool_create( &m_pool, NULL );

    svn_config_ensure( "", m_pool );

    svn_client_ctx_t    m_context;
    memset( &m_context, 0, sizeof( m_context ) );

    // get the config based on the config dir passed in
    svn_config_get_config( &m_context.config, "", m_pool );

    apr_pool_t *pool = svn_pool_create( NULL );

    svn_opt_revision_t revision;
    revision.kind = svn_opt_revision_working;


    char *path = argv[1];

    svn_boolean_t recurse = atoi( argv[3] );

    int t0 = elapse_time();

    int max_calls = atoi( argv[2] );
    int i;
    for( i=0; i<max_calls; i++ )
    {
        apr_array_header_t *props = NULL;

        svn_error_t *error = svn_client_proplist
            (
            &props,
            path,
            &revision,
            recurse,
            &m_context,
            pool
            );
    }

    int t1 = elapse_time();

    int total = t1 - t0;

    std::cout << "Time for " << max_calls << " calls " << total << "ms recurse=" << recurse << std::endl;
    std::cout << "Time for " << 1 << " call " << total/max_calls << "ms recurse=" << recurse << std::endl;

    return 0;
}