/* Helper function: push the svn_wc_entry_t for WCPATH at RECEIVER/BATON, and possibly recurse over more entries. */ static svn_error_t * crawl_entries(const char *wcpath, svn_info_receiver_t receiver, void *receiver_baton, svn_depth_t depth, apr_hash_t *changelist_hash, svn_client_ctx_t *ctx, apr_pool_t *pool) { svn_wc_adm_access_t *adm_access; int adm_lock_level = SVN_WC__LEVELS_TO_LOCK_FROM_DEPTH(depth); struct found_entry_baton fe_baton; SVN_ERR(svn_wc_adm_probe_open3(&adm_access, NULL, wcpath, FALSE, adm_lock_level, ctx->cancel_func, ctx->cancel_baton, pool)); fe_baton.changelist_hash = changelist_hash; fe_baton.receiver = receiver; fe_baton.receiver_baton = receiver_baton; fe_baton.adm_access = adm_access; return svn_wc_walk_entries3(wcpath, adm_access, &entry_walk_callbacks, &fe_baton, depth, FALSE, ctx->cancel_func, ctx->cancel_baton, pool); }
Py::Object pysvn_client::cmd_info( const Py::Tuple &a_args, const Py::Dict &a_kws ) { static argument_description args_desc[] = { { true, name_path }, { false, NULL } }; FunctionArguments args( "info", args_desc, a_args, a_kws ); args.check(); std::string path( args.getUtf8String( name_path ) ); SvnPool pool( m_context ); const svn_wc_entry_t *entry = NULL; try { checkThreadPermission(); PythonAllowThreads permission( m_context ); svn_wc_adm_access_t *adm_access = NULL; #if defined( PYSVN_HAS_WC_ADM_PROBE_OPEN3 ) const char *c_norm_path = svn_dirent_internal_style( path.c_str(), pool ); std::string norm_path( c_norm_path ); svn_error_t *error = svn_wc_adm_probe_open3( &adm_access, NULL, norm_path.c_str(), false, 0, NULL, NULL, pool ); #else std::string norm_path( svnNormalisedPath( path, pool ) ); svn_error_t *error = svn_wc_adm_probe_open( &adm_access, NULL, norm_path.c_str(), false, false, pool ); #endif permission.allowThisThread(); if( error != NULL ) throw SvnException( error ); permission.allowOtherThreads(); error = svn_wc_entry( &entry, norm_path.c_str(), adm_access, false, pool ); permission.allowThisThread(); if( error != NULL ) throw SvnException( error ); } catch( SvnException &e ) { // use callback error over ClientException m_context.checkForError( m_module.client_error ); throw_client_error( e ); return Py::None(); // needed to remove warning about return value missing } if( entry == NULL ) return Py::None(); return toObject( *entry, pool, m_wrapper_entry ); }
/* Helper function: push the svn_wc_entry_t for WCPATH at RECEIVER/BATON, and possibly recurse over more entries. */ static svn_error_t * crawl_entries(const char *wcpath, svn_info_receiver_t receiver, void *receiver_baton, svn_depth_t depth, apr_hash_t *changelist_hash, svn_client_ctx_t *ctx, apr_pool_t *pool) { svn_wc_adm_access_t *adm_access; const svn_wc_entry_t *entry; int adm_lock_level = SVN_WC__LEVELS_TO_LOCK_FROM_DEPTH(depth); SVN_ERR(svn_wc_adm_probe_open3(&adm_access, NULL, wcpath, FALSE, adm_lock_level, ctx->cancel_func, ctx->cancel_baton, pool)); SVN_ERR(svn_wc__entry_versioned(&entry, wcpath, adm_access, FALSE, pool)); if (entry->kind == svn_node_file) { if (SVN_WC__CL_MATCH(changelist_hash, entry)) { svn_info_t *info; SVN_ERR(build_info_from_entry(&info, entry, pool)); return receiver(receiver_baton, wcpath, info, pool); } } else if (entry->kind == svn_node_dir) { struct found_entry_baton fe_baton; fe_baton.changelist_hash = changelist_hash; fe_baton.receiver = receiver; fe_baton.receiver_baton = receiver_baton; SVN_ERR(svn_wc_walk_entries3(wcpath, adm_access, &entry_walk_callbacks, &fe_baton, depth, FALSE, ctx->cancel_func, ctx->cancel_baton, pool)); } return SVN_NO_ERROR; }
svn_error_t * svn_client__derive_location(const char **url, svn_revnum_t *peg_revnum, const char *path_or_url, const svn_opt_revision_t *peg_revision, const svn_ra_session_t *ra_session, svn_wc_adm_access_t *adm_access, svn_client_ctx_t *ctx, apr_pool_t *pool) { /* If PATH_OR_URL is a local path (not a URL), we need to transform it into a URL. */ if (! svn_path_is_url(path_or_url)) { const svn_wc_entry_t *entry; if (adm_access) { SVN_ERR(svn_wc__entry_versioned(&entry, path_or_url, adm_access, FALSE, pool)); } else { svn_cancel_func_t cancel_func; void *cancel_baton; if (ctx) { cancel_func = ctx->cancel_func; cancel_baton = ctx->cancel_baton; } SVN_ERR(svn_wc_adm_probe_open3(&adm_access, NULL, path_or_url, FALSE, 0, cancel_func, cancel_baton, pool)); SVN_ERR(svn_wc__entry_versioned(&entry, path_or_url, adm_access, FALSE, pool)); SVN_ERR(svn_wc_adm_close(adm_access)); } SVN_ERR(svn_client__entry_location(url, peg_revnum, path_or_url, peg_revision->kind, entry, pool)); } else { *url = path_or_url; /* peg_revnum (if provided) will be set below. */ } /* If we haven't resolved for ourselves a numeric peg revision, do so. */ if (peg_revnum && !SVN_IS_VALID_REVNUM(*peg_revnum)) { /* Use sesspool to assure that if we opened an RA session, we close it. */ apr_pool_t *sesspool = NULL; svn_ra_session_t *session = (svn_ra_session_t *) ra_session; if (session == NULL) { sesspool = svn_pool_create(pool); SVN_ERR(svn_client__open_ra_session_internal(&session, *url, NULL, NULL, NULL, FALSE, TRUE, ctx, sesspool)); } SVN_ERR(svn_client__get_revision_number(peg_revnum, NULL, session, peg_revision, NULL, pool)); if (sesspool) svn_pool_destroy(sesspool); } return SVN_NO_ERROR; }
svn_error_t * svn_client__get_revision_number(svn_revnum_t *revnum, svn_revnum_t *youngest_rev, svn_ra_session_t *ra_session, const svn_opt_revision_t *revision, const char *path, apr_pool_t *pool) { switch (revision->kind) { case svn_opt_revision_unspecified: *revnum = SVN_INVALID_REVNUM; break; case svn_opt_revision_number: *revnum = revision->value.number; break; case svn_opt_revision_head: /* If our caller provided a value for HEAD that he wants us to use, we'll use it. Otherwise, we have to query the repository (and possible return our fetched value in *YOUNGEST_REV, too). */ if (youngest_rev && SVN_IS_VALID_REVNUM(*youngest_rev)) { *revnum = *youngest_rev; } else { if (! ra_session) return svn_error_create(SVN_ERR_CLIENT_RA_ACCESS_REQUIRED, NULL, NULL); SVN_ERR(svn_ra_get_latest_revnum(ra_session, revnum, pool)); if (youngest_rev) *youngest_rev = *revnum; } break; case svn_opt_revision_committed: case svn_opt_revision_working: case svn_opt_revision_base: case svn_opt_revision_previous: { svn_wc_adm_access_t *adm_access; const svn_wc_entry_t *ent; /* Sanity check. */ if (path == NULL) return svn_error_create(SVN_ERR_CLIENT_VERSIONED_PATH_REQUIRED, NULL, NULL); SVN_ERR(svn_wc_adm_probe_open3(&adm_access, NULL, path, FALSE, 0, NULL, NULL, pool)); SVN_ERR(svn_wc__entry_versioned(&ent, path, adm_access, FALSE, pool)); SVN_ERR(svn_wc_adm_close(adm_access)); if ((revision->kind == svn_opt_revision_base) || (revision->kind == svn_opt_revision_working)) { *revnum = ent->revision; } else { if (! SVN_IS_VALID_REVNUM(ent->cmt_rev)) return svn_error_createf(SVN_ERR_CLIENT_BAD_REVISION, NULL, _("Path '%s' has no committed " "revision"), path); *revnum = ent->cmt_rev; if (revision->kind == svn_opt_revision_previous) (*revnum)--; } } break; case svn_opt_revision_date: /* ### When revision->kind == svn_opt_revision_date, is there an ### optimization such that we can compare ### revision->value->date with the committed-date in the ### entries file (or rather, with some range of which ### committed-date is one endpoint), and sometimes avoid a ### trip over the RA layer? The only optimizations I can ### think of involve examining other entries to build a ### timespan across which committed-revision is known to be ### the head, but it doesn't seem worth it. -kff */ if (! ra_session) return svn_error_create(SVN_ERR_CLIENT_RA_ACCESS_REQUIRED, NULL, NULL); SVN_ERR(svn_ra_get_dated_revision(ra_session, revnum, revision->value.date, pool)); break; default: return svn_error_createf(SVN_ERR_CLIENT_BAD_REVISION, NULL, _("Unrecognized revision type requested for " "'%s'"), svn_path_local_style(path, pool)); } /* Final check -- if our caller provided a youngest revision, and the number we wound up with is younger than that revision, we need to stick to our caller's idea of "youngest". */ if (youngest_rev && SVN_IS_VALID_REVNUM(*youngest_rev) && SVN_IS_VALID_REVNUM(*revnum) && (*revnum > *youngest_rev)) *revnum = *youngest_rev; return SVN_NO_ERROR; }
/* This implements the `svn_opt_subcommand_t' interface. */ svn_error_t * svn_cl__propedit(apr_getopt_t *os, void *baton, apr_pool_t *pool) { svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state; svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx; const char *pname, *pname_utf8; apr_array_header_t *args, *targets; int i; /* Validate the input and get the property's name (and a UTF-8 version of that name). */ SVN_ERR(svn_opt_parse_num_args(&args, os, 1, pool)); pname = APR_ARRAY_IDX(args, 0, const char *); SVN_ERR(svn_utf_cstring_to_utf8(&pname_utf8, pname, pool)); if (! svn_prop_name_is_valid(pname_utf8)) return svn_error_createf(SVN_ERR_CLIENT_PROPERTY_NAME, NULL, _("'%s' is not a valid Subversion property name"), pname_utf8); if (opt_state->encoding && !svn_prop_needs_translation(pname_utf8)) return svn_error_create (SVN_ERR_UNSUPPORTED_FEATURE, NULL, _("--encoding option applies only to textual" " Subversion-controlled properties")); /* Suck up all the remaining arguments into a targets array */ SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os, opt_state->targets, ctx, pool)); if (opt_state->revprop) /* operate on a revprop */ { svn_revnum_t rev; const char *URL; svn_string_t *propval; svn_string_t original_propval; const char *temp_dir; /* Implicit "." is okay for revision properties; it just helps us find the right repository. */ svn_opt_push_implicit_dot_target(targets, pool); SVN_ERR(svn_cl__revprop_prepare(&opt_state->start_revision, targets, &URL, pool)); /* Fetch the current property. */ SVN_ERR(svn_client_revprop_get(pname_utf8, &propval, URL, &(opt_state->start_revision), &rev, ctx, pool)); if (! propval) { propval = svn_string_create("", pool); /* This is how we signify to svn_client_revprop_set2() that we want it to check that the original value hasn't changed, but that that original value was non-existent: */ original_propval.data = NULL; /* and .len is ignored */ } else { original_propval = *propval; } /* Run the editor on a temporary file which contains the original property value... */ SVN_ERR(svn_io_temp_dir(&temp_dir, pool)); SVN_ERR(svn_cl__edit_string_externally (&propval, NULL, opt_state->editor_cmd, temp_dir, propval, "svn-prop", ctx->config, svn_prop_needs_translation(pname_utf8), opt_state->encoding, pool)); /* ...and re-set the property's value accordingly. */ if (propval) { SVN_ERR(svn_client_revprop_set2(pname_utf8, propval, &original_propval, URL, &(opt_state->start_revision), &rev, opt_state->force, ctx, pool)); SVN_ERR (svn_cmdline_printf (pool, _("Set new value for property '%s' on revision %ld\n"), pname_utf8, rev)); } else { SVN_ERR(svn_cmdline_printf (pool, _("No changes to property '%s' on revision %ld\n"), pname_utf8, rev)); } } else if (opt_state->start_revision.kind != svn_opt_revision_unspecified) { return svn_error_createf (SVN_ERR_CL_ARG_PARSING_ERROR, NULL, _("Cannot specify revision for editing versioned property '%s'"), pname_utf8); } else /* operate on a normal, versioned property (not a revprop) */ { apr_pool_t *subpool = svn_pool_create(pool); /* The customary implicit dot rule has been prone to user error * here. For example, Jon Trowbridge <*****@*****.**> did * * $ svn propedit HACKING * * and then when he closed his editor, he was surprised to see * * Set new value for property 'HACKING' on '' * * ...meaning that the property named 'HACKING' had been set on * the current working directory, with the value taken from the * editor. So we don't do the implicit dot thing anymore; an * explicit target is always required when editing a versioned * property. */ if (targets->nelts == 0) { return svn_error_create (SVN_ERR_CL_INSUFFICIENT_ARGS, NULL, _("Explicit target argument required")); } SVN_ERR(svn_opt__eat_peg_revisions(&targets, targets, pool)); /* For each target, edit the property PNAME. */ for (i = 0; i < targets->nelts; i++) { apr_hash_t *props; const char *target = APR_ARRAY_IDX(targets, i, const char *); svn_string_t *propval, *edited_propval; const char *base_dir = target; const char *target_local; svn_wc_adm_access_t *adm_access; const svn_wc_entry_t *entry; svn_opt_revision_t peg_revision; svn_revnum_t base_rev = SVN_INVALID_REVNUM; svn_pool_clear(subpool); SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton)); /* Propedits can only happen on HEAD or the working copy, so the peg revision can be as unspecified. */ peg_revision.kind = svn_opt_revision_unspecified; /* Fetch the current property. */ SVN_ERR(svn_client_propget3(&props, pname_utf8, target, &peg_revision, &(opt_state->start_revision), &base_rev, svn_depth_empty, NULL, ctx, subpool)); /* Get the property value. */ propval = apr_hash_get(props, target, APR_HASH_KEY_STRING); if (! propval) propval = svn_string_create("", subpool); if (svn_path_is_url(target)) { /* For URLs, put the temporary file in the current directory. */ base_dir = "."; } else { if (opt_state->message || opt_state->filedata || opt_state->revprop_table) { return svn_error_create (SVN_ERR_CL_UNNECESSARY_LOG_MESSAGE, NULL, _("Local, non-commit operations do not take a log message " "or revision properties")); } /* Split the path if it is a file path. */ SVN_ERR(svn_wc_adm_probe_open3(&adm_access, NULL, target, FALSE, 0, ctx->cancel_func, ctx->cancel_baton, subpool)); SVN_ERR(svn_wc_entry(&entry, target, adm_access, FALSE, subpool)); if (! entry) return svn_error_createf (SVN_ERR_ENTRY_NOT_FOUND, NULL, _("'%s' does not appear to be a working copy path"), target); if (entry->kind == svn_node_file) svn_path_split(target, &base_dir, NULL, subpool); } /* Run the editor on a temporary file which contains the original property value... */ SVN_ERR(svn_cl__edit_string_externally(&edited_propval, NULL, opt_state->editor_cmd, base_dir, propval, "svn-prop", ctx->config, svn_prop_needs_translation (pname_utf8), opt_state->encoding, subpool)); target_local = svn_path_is_url(target) ? target : svn_path_local_style(target, subpool); /* ...and re-set the property's value accordingly. */ if (edited_propval && !svn_string_compare(propval, edited_propval)) { svn_commit_info_t *commit_info = NULL; svn_error_t *err = SVN_NO_ERROR; svn_cl__check_boolean_prop_val(pname_utf8, edited_propval->data, subpool); if (ctx->log_msg_func3) SVN_ERR(svn_cl__make_log_msg_baton(&(ctx->log_msg_baton3), opt_state, NULL, ctx->config, subpool)); err = svn_client_propset3(&commit_info, pname_utf8, edited_propval, target, svn_depth_empty, opt_state->force, base_rev, NULL, opt_state->revprop_table, ctx, subpool); if (ctx->log_msg_func3) SVN_ERR(svn_cl__cleanup_log_msg(ctx->log_msg_baton3, err, pool)); else if (err) return err; /* Print a message if we successfully committed or if it was just a wc propset (but not if the user aborted an URL propedit). */ if (commit_info || ! svn_path_is_url(target)) SVN_ERR (svn_cmdline_printf (subpool, _("Set new value for property '%s' on '%s'\n"), pname_utf8, target_local)); if (commit_info && ! opt_state->quiet) SVN_ERR(svn_cl__print_commit_info(commit_info, subpool)); } else { SVN_ERR (svn_cmdline_printf (subpool, _("No changes to property '%s' on '%s'\n"), pname_utf8, target_local)); } } svn_pool_destroy(subpool); } return SVN_NO_ERROR; }