| /* |
| * commit.c: wrappers around wc commit functionality. |
| * |
| * ==================================================================== |
| * Copyright (c) 2000-2002 CollabNet. All rights reserved. |
| * |
| * This software is licensed as described in the file COPYING, which |
| * you should have received as part of this distribution. The terms |
| * are also available at http://subversion.tigris.org/license-1.html. |
| * If newer versions of this license are posted there, you may use a |
| * newer version instead, at your option. |
| * |
| * This software consists of voluntary contributions made by many |
| * individuals. For exact contribution history, see the revision |
| * history and logs, available at http://subversion.tigris.org/. |
| * ==================================================================== |
| */ |
| |
| /* ==================================================================== */ |
| |
| |
| |
| /*** Includes. ***/ |
| |
| #include <string.h> |
| #include <assert.h> |
| #include <apr_strings.h> |
| #include "svn_wc.h" |
| #include "svn_ra.h" |
| #include "svn_delta.h" |
| #include "svn_client.h" |
| #include "svn_string.h" |
| #include "svn_pools.h" |
| #include "svn_error.h" |
| #include "svn_path.h" |
| #include "svn_test.h" |
| #include "svn_io.h" |
| |
| #include "client.h" |
| |
| |
| /* Shared internals of import and commit. */ |
| |
| /* Apply PATH's contents (as a delta against the empty string) to |
| FILE_BATON in EDITOR. Use POOL for any temporary allocation. */ |
| static svn_error_t * |
| send_file_contents (svn_stringbuf_t *path, |
| void *file_baton, |
| const svn_delta_editor_t *editor, |
| apr_pool_t *pool) |
| { |
| svn_stream_t *contents; |
| svn_txdelta_window_handler_t handler; |
| void *handler_baton; |
| apr_file_t *f = NULL; |
| apr_status_t apr_err; |
| |
| /* Get an apr file for PATH. */ |
| apr_err = apr_file_open (&f, path->data, APR_READ, APR_OS_DEFAULT, pool); |
| if (! APR_STATUS_IS_SUCCESS (apr_err)) |
| return svn_error_createf (apr_err, 0, NULL, pool, |
| "error opening `%s' for reading", path->data); |
| |
| /* Get a readable stream of the file's contents. */ |
| contents = svn_stream_from_aprfile (f, pool); |
| |
| /* Get an editor func that wants to consume the delta stream. */ |
| SVN_ERR (editor->apply_textdelta (file_baton, &handler, &handler_baton)); |
| |
| /* Send the file's contents to the delta-window handler. */ |
| SVN_ERR (svn_txdelta_send_stream (contents, handler, handler_baton, pool)); |
| |
| /* Close the file. */ |
| apr_err = apr_file_close (f); |
| if (! APR_STATUS_IS_SUCCESS (apr_err)) |
| return svn_error_createf |
| (apr_err, 0, NULL, pool, "error closing `%s'", path->data); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| /* Import file PATH as EDIT_PATH in the repository directory indicated |
| * by DIR_BATON in EDITOR. |
| * |
| * Use POOL for any temporary allocation. */ |
| static svn_error_t * |
| import_file (apr_hash_t *files, |
| const svn_delta_editor_t *editor, |
| void *dir_baton, |
| const svn_stringbuf_t *path, |
| const char *edit_path, |
| apr_pool_t *pool) |
| { |
| void *file_baton; |
| const char *mimetype; |
| apr_pool_t *hash_pool = apr_hash_pool_get (files); |
| svn_stringbuf_t *filepath = svn_stringbuf_dup (path, hash_pool); |
| |
| /* Add the file, using the pool from the FILES hash. */ |
| SVN_ERR (editor->add_file (edit_path, dir_baton, NULL, SVN_INVALID_REVNUM, |
| hash_pool, &file_baton)); |
| |
| /* If the file has a discernable mimetype, add that as a property to |
| the file. */ |
| SVN_ERR (svn_io_detect_mimetype (&mimetype, path->data, pool)); |
| if (mimetype) |
| SVN_ERR (editor->change_file_prop (file_baton, SVN_PROP_MIME_TYPE, |
| svn_string_create (mimetype, pool), |
| pool)); |
| |
| /* Finally, add the file's path and baton to the FILES hash. */ |
| apr_hash_set (files, filepath->data, filepath->len, (void *)file_baton); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| /* Import directory PATH into the repository directory indicated by |
| * DIR_BATON in EDITOR. ROOT_PATH is the path imported as the root |
| * directory, so all edits are relative to that. |
| * |
| * Use POOL for any temporary allocation. */ |
| static svn_error_t * |
| import_dir (apr_hash_t *files, |
| const svn_delta_editor_t *editor, |
| void *dir_baton, |
| const svn_stringbuf_t *path, |
| const svn_stringbuf_t *edit_path, |
| apr_pool_t *pool) |
| { |
| apr_pool_t *subpool = svn_pool_create (pool); /* iteration pool */ |
| apr_dir_t *dir; |
| apr_finfo_t finfo; |
| apr_status_t apr_err; |
| apr_int32_t flags = APR_FINFO_TYPE | APR_FINFO_NAME; |
| svn_stringbuf_t *this_path, *this_edit_path; |
| |
| if ((apr_err = apr_dir_open (&dir, path->data, pool))) |
| return svn_error_createf (apr_err, 0, NULL, pool, |
| "unable to open directory %s", path->data); |
| |
| this_path = svn_stringbuf_dup (path, pool); |
| this_edit_path = svn_stringbuf_dup (edit_path, pool); |
| |
| for (apr_err = apr_dir_read (&finfo, flags, dir); |
| APR_STATUS_IS_SUCCESS (apr_err); |
| svn_pool_clear (subpool), apr_err = apr_dir_read (&finfo, flags, dir)) |
| { |
| svn_stringbuf_t *name; |
| |
| if (finfo.filetype == APR_DIR) |
| { |
| /* Skip entries for this dir and its parent. |
| ### kff todo: APR actually promises that they'll come first, |
| so this guard could be moved outside the loop. */ |
| if (! (strcmp (finfo.name, ".") && strcmp (finfo.name, ".."))) |
| continue; |
| |
| /* If someone's trying to import a directory named the same |
| as our administrative directories, that's probably not |
| what they wanted to do. Someday we can take an option to |
| make these subdirs be silently ignored, but for now, |
| seems safest to error. */ |
| if (strcmp (finfo.name, SVN_WC_ADM_DIR_NAME) == 0) |
| return svn_error_createf |
| (SVN_ERR_CL_ADM_DIR_RESERVED, 0, NULL, subpool, |
| "cannot import directory named \"%s\" (in `%s')", |
| finfo.name, path->data); |
| } |
| |
| /* Make a stringbuf version of the entry name, and append it as |
| a path component to THIS_PATH and THIS_EDIT_PATH. */ |
| name = svn_stringbuf_create (finfo.name, subpool); |
| svn_path_add_component (this_path, name); |
| svn_path_add_component (this_edit_path, name); |
| |
| if (finfo.filetype == APR_DIR) |
| { |
| void *this_dir_baton; |
| |
| /* Add the new subdirectory, getting a descent baton from |
| the editor. */ |
| SVN_ERR (editor->add_directory (this_edit_path->data, dir_baton, |
| NULL, SVN_INVALID_REVNUM, subpool, |
| &this_dir_baton)); |
| |
| /* Recurse. */ |
| SVN_ERR (import_dir (files, editor, this_dir_baton, |
| this_path, this_edit_path, subpool)); |
| |
| /* Finally, close the sub-directory. */ |
| SVN_ERR (editor->close_directory (this_dir_baton)); |
| } |
| else if (finfo.filetype == APR_REG) |
| { |
| /* Import a file. */ |
| SVN_ERR (import_file (files, editor, dir_baton, |
| this_path, this_edit_path->data, subpool)); |
| } |
| else |
| { |
| /* It's not a file or dir, so we can't import it (yet). |
| No need to error, just ignore the thing. */ |
| } |
| |
| /* Hack THIS_PATH and THIS_EDIT_PATH back to their original sizes. */ |
| svn_stringbuf_chop (this_path, |
| (path->len ? name->len + 1 : name->len)); |
| svn_stringbuf_chop (this_edit_path, |
| (edit_path->len ? name->len + 1 : name->len)); |
| } |
| |
| /* Check that the loop exited cleanly. */ |
| if (! (APR_STATUS_IS_ENOENT (apr_err))) |
| return svn_error_createf |
| (apr_err, 0, NULL, subpool, "error during import of `%s'", path->data); |
| |
| /* Yes, it exited cleanly, so close the dir. */ |
| else if ((apr_err = apr_dir_close (dir))) |
| return svn_error_createf |
| (apr_err, 0, NULL, subpool, "error closing dir `%s'", path->data); |
| |
| svn_pool_destroy (subpool); |
| return SVN_NO_ERROR; |
| } |
| |
| |
| |
| /*** Public interfaces. ***/ |
| |
| /* Recursively import PATH to a repository using EDITOR and |
| * EDIT_BATON. PATH can be a file or directory. |
| * |
| * NEW_ENTRY is the name to use in the repository. If PATH is a |
| * directory, NEW_ENTRY may be null, which creates as many new entries |
| * in the top repository target directory as there are entries in the |
| * top of PATH; but if NEW_ENTRY is non-null, it is the name of a new |
| * subdirectory in the repository to hold the import. If PATH is a |
| * file, NEW_ENTRY may not be null. |
| * |
| * NEW_ENTRY can never be the empty string. |
| * |
| * Use POOL for any temporary allocation. |
| * |
| * Note: the repository directory receiving the import was specified |
| * when the editor was fetched. (I.e, when EDITOR->open_root() is |
| * called, it returns a directory baton for that directory, which is |
| * not necessarily the root.) |
| */ |
| static svn_error_t * |
| import (const svn_stringbuf_t *path, |
| const svn_stringbuf_t *new_entry, |
| const svn_delta_editor_t *editor, |
| void *edit_baton, |
| apr_pool_t *pool) |
| { |
| void *root_baton; |
| enum svn_node_kind kind; |
| apr_hash_t *files = apr_hash_make (pool); |
| apr_pool_t *subpool = svn_pool_create (pool); /* for post-fix textdeltas */ |
| apr_hash_index_t *hi; |
| |
| /* Get a root dir baton. We pass an invalid revnum to open_root |
| to mean "base this on the youngest revision". Should we have an |
| SVN_YOUNGEST_REVNUM defined for these purposes? */ |
| SVN_ERR (editor->open_root (edit_baton, SVN_INVALID_REVNUM, |
| pool, &root_baton)); |
| |
| /* Import a file or a directory tree. */ |
| SVN_ERR (svn_io_check_path (path->data, &kind, pool)); |
| |
| /* Note that there is no need to check whether PATH's basename is |
| the same name that we reserve for our admistritave |
| subdirectories. It would be strange, but not illegal to import |
| the contents of a directory of that name, because the directory's |
| own name is not part of those contents. Of course, if something |
| underneath it also has our reserved name, then we'll error. */ |
| |
| if (kind == svn_node_file) |
| { |
| if (! new_entry) |
| return svn_error_create |
| (SVN_ERR_UNKNOWN_NODE_KIND, 0, NULL, pool, |
| "new entry name required when importing a file"); |
| |
| SVN_ERR (import_file (files, editor, root_baton, |
| path, new_entry->data, pool)); |
| } |
| else if (kind == svn_node_dir) |
| { |
| void *new_dir_baton = NULL; |
| |
| /* Grab a new baton, making two we'll have to close. */ |
| if (new_entry) |
| SVN_ERR (editor->add_directory (new_entry->data, root_baton, |
| NULL, SVN_INVALID_REVNUM, |
| pool, &new_dir_baton)); |
| |
| SVN_ERR (import_dir |
| (files, editor, new_dir_baton ? new_dir_baton : root_baton, |
| path, new_entry ? new_entry : svn_stringbuf_create ("", pool), |
| pool)); |
| |
| /* Close one baton or two. */ |
| if (new_dir_baton) |
| SVN_ERR (editor->close_directory (new_dir_baton)); |
| } |
| else if (kind == svn_node_none) |
| { |
| return svn_error_createf |
| (SVN_ERR_UNKNOWN_NODE_KIND, 0, NULL, pool, |
| "'%s' does not exist.", path->data); |
| } |
| |
| SVN_ERR (editor->close_directory (root_baton)); |
| |
| /* Do post-fix textdeltas here! */ |
| for (hi = apr_hash_first (pool, files); hi; hi = apr_hash_next (hi)) |
| { |
| const void *key; |
| apr_ssize_t keylen; |
| void *file_baton; |
| svn_stringbuf_t *full_path; |
| |
| apr_hash_this (hi, &key, &keylen, &file_baton); |
| full_path = svn_stringbuf_create ((char *) key, subpool); |
| SVN_ERR (send_file_contents (full_path, file_baton, editor, subpool)); |
| SVN_ERR (editor->close_file (file_baton)); |
| |
| /* Clear our per-iteration subpool. */ |
| svn_pool_clear (subpool); |
| } |
| |
| /* Destroy the per-iteration subpool. */ |
| svn_pool_destroy (subpool); |
| |
| SVN_ERR (editor->close_edit (edit_baton)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| static svn_error_t * |
| get_xml_editor (apr_file_t **xml_hnd, |
| const svn_delta_editor_t **editor, |
| void **edit_baton, |
| const char *xml_file, |
| apr_pool_t *pool) |
| { |
| apr_status_t apr_err; |
| |
| /* Open the xml file for writing. */ |
| if ((apr_err = apr_file_open (xml_hnd, xml_file, (APR_WRITE | APR_CREATE), |
| APR_OS_DEFAULT, pool))) |
| return svn_error_createf (apr_err, 0, NULL, pool, |
| "error opening %s", xml_file); |
| |
| /* ... we need an XML commit editor. */ |
| return svn_delta_get_xml_editor (svn_stream_from_aprfile (*xml_hnd, pool), |
| editor, edit_baton, pool); |
| } |
| |
| |
| static svn_error_t * |
| get_ra_editor (void **ra_baton, |
| void **session, |
| svn_ra_plugin_t **ra_lib, |
| const svn_delta_editor_t **editor, |
| void **edit_baton, |
| svn_client_auth_baton_t *auth_baton, |
| svn_stringbuf_t *base_url, |
| svn_stringbuf_t *base_dir, |
| svn_stringbuf_t *log_msg, |
| apr_array_header_t *commit_items, |
| svn_revnum_t *committed_rev, |
| const char **committed_date, |
| const char **committed_author, |
| svn_boolean_t is_commit, |
| apr_pool_t *pool) |
| { |
| /* Get the RA vtable that matches URL. */ |
| SVN_ERR (svn_ra_init_ra_libs (ra_baton, pool)); |
| SVN_ERR (svn_ra_get_ra_library (ra_lib, *ra_baton, |
| base_url->data, pool)); |
| |
| /* Open an RA session to URL. */ |
| SVN_ERR (svn_client__open_ra_session (session, *ra_lib, |
| base_url, base_dir, |
| commit_items, is_commit, |
| is_commit, !is_commit, |
| auth_baton, pool)); |
| |
| /* Fetch RA commit editor, giving it svn_wc_process_committed(). */ |
| return (*ra_lib)->get_commit_editor (*session, editor, edit_baton, |
| committed_rev, committed_date, |
| committed_author, log_msg); |
| } |
| |
| |
| /*** Public Interfaces. ***/ |
| |
| svn_error_t * |
| svn_client_import (svn_client_commit_info_t **commit_info, |
| const svn_delta_editor_t *before_editor, |
| void *before_edit_baton, |
| const svn_delta_editor_t *after_editor, |
| void *after_edit_baton, |
| svn_client_auth_baton_t *auth_baton, |
| svn_stringbuf_t *path, |
| svn_stringbuf_t *url, |
| svn_stringbuf_t *new_entry, |
| svn_client_get_commit_log_t log_msg_func, |
| void *log_msg_baton, |
| svn_stringbuf_t *xml_dst, |
| svn_revnum_t revision, |
| apr_pool_t *pool) |
| { |
| apr_status_t apr_err; |
| svn_error_t *err; |
| svn_stringbuf_t *log_msg; |
| const svn_delta_editor_t *editor; |
| void *edit_baton; |
| void *ra_baton, *session; |
| svn_ra_plugin_t *ra_lib; |
| svn_revnum_t committed_rev = SVN_INVALID_REVNUM; |
| const char *committed_date = NULL; |
| const char *committed_author = NULL; |
| apr_file_t *xml_hnd; |
| svn_boolean_t use_xml = (xml_dst && xml_dst->data) ? TRUE : FALSE; |
| |
| /* Sanity check: NEW_ENTRY can be null or non-empty, but it can't be |
| empty. */ |
| if (new_entry && (strcmp (new_entry->data, "") == 0)) |
| return svn_error_create (SVN_ERR_FS_PATH_SYNTAX, 0, NULL, pool, |
| "empty string is an invalid entry name"); |
| |
| /* The repository doesn't know about the reserved. */ |
| if (new_entry && strcmp (new_entry->data, SVN_WC_ADM_DIR_NAME) == 0) |
| return svn_error_createf |
| (SVN_ERR_CL_ADM_DIR_RESERVED, 0, NULL, pool, |
| "the name \"%s\" is reserved and cannot be imported", |
| SVN_WC_ADM_DIR_NAME); |
| |
| /* Create a new commit item and add it to the array. */ |
| if (log_msg_func) |
| { |
| svn_client_commit_item_t *item; |
| apr_array_header_t *commit_items |
| = apr_array_make (pool, 1, sizeof (item)); |
| |
| item = apr_pcalloc (pool, sizeof (*item)); |
| item->path = svn_stringbuf_dup (path, pool); |
| item->state_flags = SVN_CLIENT_COMMIT_ITEM_ADD; |
| (*((svn_client_commit_item_t **) apr_array_push (commit_items))) |
| = item; |
| |
| SVN_ERR ((*log_msg_func) (&log_msg, commit_items, log_msg_baton, pool)); |
| if (! log_msg) |
| return SVN_NO_ERROR; |
| } |
| else |
| log_msg = svn_stringbuf_create ("", pool); |
| |
| /* If we're importing to XML ... */ |
| if (use_xml) |
| SVN_ERR (get_xml_editor (&xml_hnd, &editor, &edit_baton, |
| xml_dst->data, pool)); |
| |
| /* Else we're importing to an RA layer. */ |
| else |
| SVN_ERR (get_ra_editor (&ra_baton, &session, &ra_lib, |
| &editor, &edit_baton, auth_baton, url, path, |
| log_msg, NULL, &committed_rev, &committed_date, |
| &committed_author, FALSE, pool)); |
| |
| /* Wrap the resulting editor with BEFORE and AFTER editors. */ |
| svn_delta_wrap_editor (&editor, &edit_baton, |
| before_editor, before_edit_baton, |
| editor, edit_baton, |
| after_editor, after_edit_baton, pool); |
| |
| /* If an error occured during the commit, abort the edit and return |
| the error. We don't even care if the abort itself fails. */ |
| if ((err = import (path, new_entry, editor, edit_baton, pool))) |
| { |
| editor->abort_edit (edit_baton); |
| return err; |
| } |
| |
| /* Finish the import. */ |
| if (use_xml) |
| { |
| /* If we were committing into XML, close the xml file. */ |
| if ((apr_err = apr_file_close (xml_hnd))) |
| return svn_error_createf (apr_err, 0, NULL, pool, |
| "error closing %s", xml_dst->data); |
| |
| /* Use REVISION for COMMITTED_REV. */ |
| committed_rev = revision; |
| } |
| else |
| { |
| /* We were committing to RA, so close the session. */ |
| SVN_ERR (ra_lib->close (session)); |
| } |
| |
| /* Finally, fill in the commit_info structure. */ |
| *commit_info = svn_client__make_commit_info (committed_rev, |
| committed_author, |
| committed_date, |
| pool); |
| return SVN_NO_ERROR; |
| } |
| |
| |
| static svn_error_t * |
| unlock_dirs (apr_hash_t *locked_dirs, |
| apr_pool_t *pool) |
| { |
| apr_hash_index_t *hi; |
| |
| /* Split if there's nothing to be done. */ |
| if (! locked_dirs) |
| return SVN_NO_ERROR; |
| |
| /* Clean up any locks. */ |
| for (hi = apr_hash_first (pool, locked_dirs); hi; hi = apr_hash_next (hi)) |
| { |
| const void *key; |
| apr_ssize_t keylen; |
| void *val; |
| svn_stringbuf_t *strkey; |
| |
| apr_hash_this (hi, &key, &keylen, &val); |
| strkey = svn_stringbuf_ncreate ((const char *)key, keylen, pool); |
| SVN_ERR (svn_wc_unlock (strkey, pool)); |
| } |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| static svn_error_t * |
| remove_tmpfiles (apr_hash_t *tempfiles, |
| apr_pool_t *pool) |
| { |
| apr_hash_index_t *hi; |
| |
| /* Split if there's nothing to be done. */ |
| if (! tempfiles) |
| return SVN_NO_ERROR; |
| |
| /* Clean up any tempfiles. */ |
| for (hi = apr_hash_first (pool, tempfiles); hi; hi = apr_hash_next (hi)) |
| { |
| const void *key; |
| apr_ssize_t keylen; |
| void *val; |
| svn_node_kind_t kind; |
| |
| apr_hash_this (hi, &key, &keylen, &val); |
| SVN_ERR (svn_io_check_path ((const char *)key, &kind, pool)); |
| if (kind == svn_node_file) |
| SVN_ERR (svn_io_remove_file ((const char *)key, pool)); |
| } |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| |
| static svn_error_t * |
| reconcile_errors (svn_error_t *commit_err, |
| svn_error_t *unlock_err, |
| svn_error_t *bump_err, |
| svn_error_t *cleanup_err, |
| apr_pool_t *pool) |
| { |
| svn_error_t *err; |
| |
| /* Early release (for good behavior). */ |
| if (! (commit_err || unlock_err || bump_err || cleanup_err)) |
| return SVN_NO_ERROR; |
| |
| /* If there was a commit error, start off our error chain with |
| that. */ |
| if (commit_err) |
| { |
| commit_err = svn_error_quick_wrap |
| (commit_err, "Commit failed (details follow):"); |
| err = commit_err; |
| } |
| |
| /* Else, create a new "general" error that will head off the errors |
| that follow. */ |
| else |
| err = svn_error_create (SVN_ERR_GENERAL, 0, NULL, pool, |
| "Commit succeeded, but other errors follow:"); |
| |
| /* If there was an unlock error... */ |
| if (unlock_err) |
| { |
| /* Wrap the error with some headers. */ |
| unlock_err = svn_error_quick_wrap |
| (unlock_err, "Error unlocking locked dirs (details follow):"); |
| |
| /* Append this error to the chain. */ |
| svn_error_compose (err, unlock_err); |
| } |
| |
| /* If there was a bumping error... */ |
| if (bump_err) |
| { |
| /* Wrap the error with some headers. */ |
| bump_err = svn_error_quick_wrap |
| (bump_err, "Error bumping revisions post-commit (details follow):"); |
| |
| /* Append this error to the chain. */ |
| svn_error_compose (err, bump_err); |
| } |
| |
| /* If there was a cleanup error... */ |
| if (cleanup_err) |
| { |
| /* Wrap the error with some headers. */ |
| cleanup_err = svn_error_quick_wrap |
| (cleanup_err, "Error in post-commit clean-up (details follow):"); |
| |
| /* Append this error to the chain. */ |
| svn_error_compose (err, cleanup_err); |
| } |
| |
| return err; |
| } |
| |
| |
| svn_error_t * |
| svn_client_commit (svn_client_commit_info_t **commit_info, |
| const svn_delta_editor_t *before_editor, |
| void *before_edit_baton, |
| const svn_delta_editor_t *after_editor, |
| void *after_edit_baton, |
| svn_wc_notify_func_t notify_func, |
| void *notify_baton, |
| svn_client_auth_baton_t *auth_baton, |
| const apr_array_header_t *targets, |
| svn_client_get_commit_log_t log_msg_func, |
| void *log_msg_baton, |
| svn_stringbuf_t *xml_dst, |
| svn_revnum_t revision, |
| apr_pool_t *pool) |
| { |
| const svn_delta_editor_t *editor; |
| void *edit_baton; |
| void *ra_baton, *session; |
| svn_stringbuf_t *log_msg; |
| svn_revnum_t committed_rev = SVN_INVALID_REVNUM; |
| const char *committed_date = NULL; |
| const char *committed_author = NULL; |
| svn_ra_plugin_t *ra_lib; |
| svn_stringbuf_t *base_dir, *base_url; |
| apr_array_header_t *rel_targets; |
| apr_hash_t *committables, *locked_dirs, *tempfiles = NULL; |
| apr_array_header_t *commit_items; |
| apr_status_t apr_err = 0; |
| apr_file_t *xml_hnd = NULL; |
| svn_error_t *cmt_err = NULL, *unlock_err = NULL; |
| svn_error_t *bump_err = NULL, *cleanup_err = NULL; |
| svn_boolean_t use_xml = (xml_dst && xml_dst->data) ? TRUE : FALSE; |
| svn_boolean_t commit_in_progress = FALSE; |
| svn_stringbuf_t *display_dir = svn_stringbuf_create (".", pool); |
| int i; |
| |
| /* Condense the target list. */ |
| SVN_ERR (svn_path_condense_targets (&base_dir, &rel_targets, targets, pool)); |
| |
| /* If we calculated only a base_dir and no relative targets, this |
| must mean that we are being asked to commit a single directory. |
| In order to do this properly, we need to anchor our commit up one |
| directory level, so long as our anchor is still a versioned |
| directory. */ |
| if ((! rel_targets) || (! rel_targets->nelts)) |
| { |
| svn_stringbuf_t *parent_dir, *name; |
| |
| SVN_ERR (svn_wc_get_actual_target (base_dir, &parent_dir, &name, pool)); |
| if (name) |
| { |
| /* Our new "grandfather directory" is the parent directory |
| of the former one. */ |
| svn_stringbuf_set (base_dir, parent_dir->data); |
| |
| /* Make the array if it wasn't already created. */ |
| if (! rel_targets) |
| rel_targets = apr_array_make (pool, targets->nelts, sizeof (name)); |
| |
| /* Now, push this name as a relative path to our new |
| base directory. */ |
| (*((svn_stringbuf_t **)apr_array_push (rel_targets))) = name; |
| } |
| } |
| |
| /* Crawl the working copy for commit items. */ |
| if ((cmt_err = svn_client__harvest_committables (&committables, |
| &locked_dirs, |
| base_dir, |
| rel_targets, |
| pool))) |
| goto cleanup; |
| |
| /* ### todo: Currently there should be only one hash entry, which |
| has a hacked name until we have the entries files storing |
| canonical repository URLs. Then, the hacked name can go away |
| and be replaced with a canonical repos URL, and from there we |
| are poised to started handling nested working copies. */ |
| if (! ((commit_items = apr_hash_get (committables, |
| SVN_CLIENT__SINGLE_REPOS_NAME, |
| APR_HASH_KEY_STRING)))) |
| goto cleanup; |
| |
| /* Go get a log message. If an error occurs, or no log message is |
| specified, abort the operation. */ |
| if (log_msg_func) |
| { |
| cmt_err = (*log_msg_func)(&log_msg, commit_items, log_msg_baton, pool); |
| if (cmt_err || (! log_msg)) |
| goto cleanup; |
| } |
| else |
| log_msg = svn_stringbuf_create ("", pool); |
| |
| /* Sort and condense our COMMIT_ITEMS. */ |
| if ((cmt_err = svn_client__condense_commit_items (&base_url, |
| commit_items, |
| pool))) |
| goto cleanup; |
| |
| /* If we're committing to XML ... */ |
| if (use_xml) |
| { |
| if ((cmt_err = get_xml_editor (&xml_hnd, &editor, &edit_baton, |
| xml_dst->data, pool))) |
| goto cleanup; |
| |
| /* Make a note that we have a commit-in-progress. */ |
| commit_in_progress = TRUE; |
| } |
| |
| /* Else we're commit to RA */ |
| else |
| { |
| svn_revnum_t head = SVN_INVALID_REVNUM; |
| |
| if ((cmt_err = get_ra_editor (&ra_baton, &session, &ra_lib, |
| &editor, &edit_baton, auth_baton, |
| base_url, base_dir, log_msg, |
| commit_items, &committed_rev, |
| &committed_date, &committed_author, |
| TRUE, pool))) |
| goto cleanup; |
| |
| /* Make a note that we have a commit-in-progress. */ |
| commit_in_progress = TRUE; |
| |
| /* ### Temporary: If we have any non-added directories with |
| property mods, and we're not committing to an XML file, make |
| sure those directories are up-to-date. Someday this should |
| just be protected against by the server. */ |
| for (i = 0; i < commit_items->nelts; i++) |
| { |
| svn_client_commit_item_t *item |
| = ((svn_client_commit_item_t **) commit_items->elts)[i]; |
| if ((item->kind == svn_node_dir) |
| && (item->state_flags & SVN_CLIENT_COMMIT_ITEM_PROP_MODS) |
| && (! (item->state_flags & SVN_CLIENT_COMMIT_ITEM_ADD))) |
| { |
| if (! SVN_IS_VALID_REVNUM (head)) |
| { |
| if ((cmt_err = ra_lib->get_latest_revnum (session, &head))) |
| goto cleanup; |
| } |
| |
| if (item->revision != head) |
| { |
| cmt_err = svn_error_createf |
| (SVN_ERR_WC_NOT_UP_TO_DATE, 0, NULL, pool, |
| "Cannot commit propchanges for directory '%s'", |
| item->path->data); |
| goto cleanup; |
| } |
| } |
| } |
| } |
| |
| /* Wrap the resulting editor with BEFORE and AFTER editors. */ |
| svn_delta_wrap_editor (&editor, &edit_baton, |
| before_editor, before_edit_baton, |
| editor, edit_baton, |
| after_editor, after_edit_baton, pool); |
| |
| |
| /* Calculate a display_dir. */ |
| if ((cmt_err = svn_path_get_absolute (&display_dir, display_dir, pool))) |
| goto cleanup; |
| |
| /* Perform the commit. */ |
| cmt_err = svn_client__do_commit (base_url, commit_items, editor, edit_baton, |
| notify_func, notify_baton, display_dir, |
| &tempfiles, pool); |
| |
| /* Make a note that our commit is finished. */ |
| commit_in_progress = FALSE; |
| |
| /* Unlock the locked directories. */ |
| if (! ((unlock_err = unlock_dirs (locked_dirs, pool)))) |
| locked_dirs = NULL; |
| |
| /* Bump the revision if the commit went well. */ |
| if (! cmt_err) |
| { |
| if (use_xml) |
| committed_rev = revision; |
| |
| for (i = 0; i < commit_items->nelts; i++) |
| { |
| svn_client_commit_item_t *item |
| = ((svn_client_commit_item_t **) commit_items->elts)[i]; |
| svn_boolean_t recurse = FALSE; |
| |
| if ((item->state_flags & SVN_CLIENT_COMMIT_ITEM_ADD) |
| && (item->kind == svn_node_dir) |
| && (item->copyfrom_url)) |
| recurse = TRUE; |
| |
| if ((bump_err = svn_wc_process_committed (item->path, recurse, |
| committed_rev, |
| committed_date, |
| committed_author, pool))) |
| break; |
| } |
| } |
| |
| /* If we were committing into XML, close the xml file. */ |
| if (use_xml) |
| { |
| if ((apr_err = apr_file_close (xml_hnd))) |
| { |
| cleanup_err = svn_error_createf (apr_err, 0, NULL, pool, |
| "error closing %s", xml_dst->data); |
| goto cleanup; |
| } |
| |
| /* Use REVISION for COMMITTED_REV. */ |
| committed_rev = revision; |
| } |
| else |
| { |
| /* We were committing to RA, so close the session. */ |
| if ((cleanup_err = ra_lib->close (session))) |
| goto cleanup; |
| } |
| |
| /* Sleep for one second to ensure timestamp integrity. */ |
| apr_sleep (APR_USEC_PER_SEC * 1); |
| |
| cleanup: |
| /* Abort the commit if it is still in progress. */ |
| if (commit_in_progress) |
| editor->abort_edit (edit_baton); /* ignore return value */ |
| |
| /* Unlock any remaining locked dirs. */ |
| if (locked_dirs) |
| unlock_err = unlock_dirs (locked_dirs, pool); |
| |
| /* Remove any outstanding temporary text-base files. */ |
| cleanup_err = remove_tmpfiles (tempfiles, pool); |
| |
| /* Fill in the commit_info structure */ |
| *commit_info = svn_client__make_commit_info (committed_rev, |
| committed_author, |
| committed_date, pool); |
| |
| return reconcile_errors (cmt_err, unlock_err, bump_err, cleanup_err, pool); |
| } |
| |
| |
| |
| |
| /* |
| * local variables: |
| * eval: (load-file "../../tools/dev/svn-dev.el") |
| * end: */ |
