| /* |
| * ra_plugin.c : the main RA module for local repository access |
| * |
| * ==================================================================== |
| * 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/. |
| * ==================================================================== |
| */ |
| |
| #include "ra_local.h" |
| #include "svn_ra.h" |
| #include "svn_fs.h" |
| #include "svn_delta.h" |
| #include "svn_repos.h" |
| #include "svn_pools.h" |
| |
| #define APR_WANT_STRFUNC |
| #include <apr_want.h> |
| |
| /*----------------------------------------------------------------*/ |
| |
| /** Callbacks **/ |
| |
| /* A device to record the targets of commits, and ensuring that proper |
| commit closure happens on them (namely, revision setting and wc |
| property setting). This is passed to the `commit hook' routine by |
| svn_fs_get_editor. ( ) */ |
| struct commit_cleanup_baton |
| { |
| /* Allocation for this baton, as well as all committed_targets */ |
| apr_pool_t *pool; |
| |
| /* The filesystem that we just committed to. */ |
| svn_fs_t *fs; |
| |
| /* If non-null, store the new revision here. */ |
| svn_revnum_t *new_rev; |
| |
| /* If non-null, store the repository date of the commit here. */ |
| const char **committed_date; |
| |
| /* If non-null, store the repository author of the commit here. */ |
| const char **committed_author; |
| }; |
| |
| |
| /* An instance of svn_ra_local__commit_hook_t. |
| * |
| * BATON is `struct commit_cleanup_baton *'. Loop over all committed |
| * target paths in BATON->committed_targets, invoking |
| * BATON->close_func() on each one with NEW_REV. |
| * |
| * Set *(BATON->new_rev) to NEW_REV, and copy COMMITTED_DATE and |
| * COMMITTED_AUTHOR to *(BATON->committed_date) and |
| * *(BATON->committed_date) respectively, allocating the new storage |
| * in BATON->pool. |
| * |
| * This routine is originally passed as a "hook" to the filesystem |
| * commit editor. When we get here, the track-editor has already |
| * stored committed targets inside the baton. |
| */ |
| static svn_error_t * |
| cleanup_commit (svn_revnum_t new_rev, |
| const char *committed_date, |
| const char *committed_author, |
| void *baton) |
| { |
| struct commit_cleanup_baton *cb = baton; |
| |
| /* Store the new revision information in the baton. */ |
| if (cb->new_rev) |
| *(cb->new_rev) = new_rev; |
| |
| if (cb->committed_date) |
| *(cb->committed_date) = committed_date |
| ? apr_pstrdup (cb->pool, committed_date) |
| : NULL; |
| |
| if (cb->committed_author) |
| *(cb->committed_author) = committed_author |
| ? apr_pstrdup (cb->pool, committed_author) |
| : NULL; |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| |
| /* The reporter vtable needed by do_update() */ |
| |
| static const svn_ra_reporter_t ra_local_reporter = |
| { |
| svn_repos_set_path, |
| svn_repos_delete_path, |
| svn_repos_finish_report, |
| svn_repos_abort_report |
| }; |
| |
| |
| |
| /*----------------------------------------------------------------*/ |
| |
| /** The RA plugin routines **/ |
| |
| |
| static svn_error_t * |
| svn_ra_local__open (void **session_baton, |
| svn_stringbuf_t *repos_URL, |
| const svn_ra_callbacks_t *callbacks, |
| void *callback_baton, |
| apr_pool_t *pool) |
| { |
| svn_ra_local__session_baton_t *session; |
| void *a, *auth_baton; |
| svn_ra_username_authenticator_t *authenticator; |
| |
| /* Allocate and stash the session_baton args we have already. */ |
| session = apr_pcalloc (pool, sizeof(*session)); |
| session->pool = pool; |
| session->repository_URL = repos_URL; |
| |
| /* Get the username by "pulling" it from the callbacks. */ |
| SVN_ERR (callbacks->get_authenticator (&a, |
| &auth_baton, |
| svn_ra_auth_username, |
| callback_baton, pool)); |
| |
| authenticator = (svn_ra_username_authenticator_t *) a; |
| |
| SVN_ERR (authenticator->get_username (&(session->username), |
| auth_baton, FALSE, pool)); |
| |
| /* Look through the URL, figure out which part points to the |
| repository, and which part is the path *within* the |
| repository. */ |
| SVN_ERR_W (svn_ra_local__split_URL (&(session->repos_path), |
| &(session->fs_path), |
| session->repository_URL, |
| session->pool), |
| "Unable to open an ra_local session to URL"); |
| |
| /* Open the filesystem at located at environment `repos_path' */ |
| SVN_ERR (svn_repos_open (&(session->repos), |
| session->repos_path->data, |
| session->pool)); |
| |
| /* Cache the filesystem object from the repos here for |
| convenience. */ |
| session->fs = svn_repos_fs (session->repos); |
| |
| /* Stuff the callbacks/baton here. */ |
| session->callbacks = callbacks; |
| session->callback_baton = callback_baton; |
| |
| /* ### ra_local is not going to bother to store the username in the |
| working copy. This means that the username will always be |
| fetched from getuid() or from a commandline arg, which is fine. |
| |
| The reason for this decision is that in ra_local, authentication |
| and authorization are blurred; we'd have to use authorization as |
| a *test* to decide if the authentication was valid. And we |
| certainly don't want to track every subsequent svn_fs_* call's |
| error, just to decide if it's legitmate to store a username! */ |
| |
| *session_baton = session; |
| return SVN_NO_ERROR; |
| } |
| |
| |
| |
| static svn_error_t * |
| svn_ra_local__close (void *session_baton) |
| { |
| svn_ra_local__session_baton_t *baton = |
| (svn_ra_local__session_baton_t *) session_baton; |
| |
| /* Close the repository, which will free any memory used by it. */ |
| SVN_ERR (svn_repos_close (baton->repos)); |
| |
| /* NULL out the FS cache so no one is tempted to use it again. */ |
| baton->fs = NULL; |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| |
| |
| static svn_error_t * |
| svn_ra_local__get_latest_revnum (void *session_baton, |
| svn_revnum_t *latest_revnum) |
| { |
| svn_ra_local__session_baton_t *baton = |
| (svn_ra_local__session_baton_t *) session_baton; |
| |
| SVN_ERR (svn_fs_youngest_rev (latest_revnum, baton->fs, baton->pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| |
| static svn_error_t * |
| svn_ra_local__get_dated_revision (void *session_baton, |
| svn_revnum_t *revision, |
| apr_time_t tm) |
| { |
| svn_ra_local__session_baton_t *baton = |
| (svn_ra_local__session_baton_t *) session_baton; |
| |
| SVN_ERR (svn_repos_dated_revision (revision, baton->repos, tm, baton->pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| |
| static svn_error_t * |
| svn_ra_local__get_commit_editor (void *session_baton, |
| const svn_delta_editor_t **editor, |
| void **edit_baton, |
| svn_revnum_t *new_rev, |
| const char **committed_date, |
| const char **committed_author, |
| svn_stringbuf_t *log_msg) |
| { |
| svn_ra_local__session_baton_t *sess_baton = session_baton; |
| struct commit_cleanup_baton *cb |
| = apr_pcalloc (sess_baton->pool, sizeof (*cb)); |
| |
| /* Construct a commit cleanup baton */ |
| cb->pool = sess_baton->pool; |
| cb->fs = sess_baton->fs; |
| cb->new_rev = new_rev; |
| cb->committed_date = committed_date; |
| cb->committed_author = committed_author; |
| |
| /* Get the repos commit-editor */ |
| SVN_ERR (svn_ra_local__get_editor (editor, edit_baton, sess_baton, |
| log_msg, cleanup_commit, cb, |
| sess_baton->pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| |
| static svn_error_t * |
| svn_ra_local__do_checkout (void *session_baton, |
| svn_revnum_t revision, |
| svn_boolean_t recurse, |
| const svn_delta_edit_fns_t *editor, |
| void *edit_baton) |
| { |
| svn_revnum_t revnum_to_fetch; |
| svn_ra_local__session_baton_t *sbaton = |
| (svn_ra_local__session_baton_t *) session_baton; |
| |
| if (! SVN_IS_VALID_REVNUM(revision)) |
| SVN_ERR (svn_ra_local__get_latest_revnum (sbaton, &revnum_to_fetch)); |
| else |
| revnum_to_fetch = revision; |
| |
| SVN_ERR (svn_ra_local__checkout (sbaton->fs, |
| revnum_to_fetch, |
| recurse, |
| sbaton->repository_URL, |
| sbaton->fs_path, |
| editor, edit_baton, sbaton->pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| |
| static svn_error_t * |
| svn_ra_local__do_update (void *session_baton, |
| const svn_ra_reporter_t **reporter, |
| void **report_baton, |
| svn_revnum_t update_revision, |
| svn_stringbuf_t *update_target, |
| svn_boolean_t recurse, |
| const svn_delta_edit_fns_t *update_editor, |
| void *update_baton) |
| { |
| svn_delta_edit_fns_t *pipe_editor; |
| struct svn_pipe_edit_baton *pipe_edit_baton; |
| svn_revnum_t revnum_to_update_to; |
| svn_stringbuf_t *switch_path; |
| svn_ra_local__session_baton_t *sbaton = session_baton; |
| |
| /* ### fix the update_target param at some point */ |
| const char *target; |
| target = update_target ? update_target->data : NULL; |
| |
| /* We want dir_delta to run on -identical- fs paths. */ |
| switch_path = |
| svn_stringbuf_create_from_string (sbaton->fs_path, sbaton->pool); |
| if (target) |
| svn_path_add_component_nts (switch_path, target); |
| |
| if (! SVN_IS_VALID_REVNUM(update_revision)) |
| SVN_ERR (svn_ra_local__get_latest_revnum (sbaton, &revnum_to_update_to)); |
| else |
| revnum_to_update_to = update_revision; |
| |
| /* Wrap UPDATE_EDITOR with a custom "pipe" editor that pushes extra |
| 'entry' properties into the stream, whenever {open_root, |
| open_file, open_dir, add_file, add_dir} are called. */ |
| SVN_ERR (svn_ra_local__get_update_pipe_editor |
| (&pipe_editor, |
| &pipe_edit_baton, |
| update_editor, |
| update_baton, |
| sbaton, |
| svn_stringbuf_create_from_string (sbaton->fs_path, sbaton->pool), |
| sbaton->pool)); |
| |
| /* Pass back our reporter */ |
| *reporter = &ra_local_reporter; |
| |
| /* Build a reporter baton. */ |
| return svn_repos_begin_report (report_baton, |
| revnum_to_update_to, |
| sbaton->username, |
| sbaton->repos, |
| sbaton->fs_path->data, |
| target, |
| switch_path->data, |
| TRUE, /* send text-deltas */ |
| recurse, |
| pipe_editor, pipe_edit_baton, |
| sbaton->pool); |
| } |
| |
| |
| static svn_error_t * |
| svn_ra_local__do_switch (void *session_baton, |
| const svn_ra_reporter_t **reporter, |
| void **report_baton, |
| svn_revnum_t update_revision, |
| svn_stringbuf_t *update_target, |
| svn_boolean_t recurse, |
| svn_stringbuf_t *switch_url, |
| const svn_delta_edit_fns_t *update_editor, |
| void *update_baton) |
| { |
| svn_delta_edit_fns_t *pipe_editor; |
| struct svn_pipe_edit_baton *pipe_edit_baton; |
| svn_revnum_t revnum_to_update_to; |
| const svn_string_t *switch_repos_path, *switch_fs_path; |
| svn_ra_local__session_baton_t *sbaton = session_baton; |
| svn_stringbuf_t *pipe_anchor; |
| |
| /* ### fix the update_target param at some point */ |
| const char *target; |
| target = update_target ? update_target->data : NULL; |
| |
| /* Pull the relevant fs-path portion out of switch_url. */ |
| SVN_ERR_W (svn_ra_local__split_URL (&switch_repos_path, &switch_fs_path, |
| switch_url, sbaton->pool), |
| "The 'switch' URL is invalid."); |
| |
| /* Sanity check: the switch_url better be in the same repository as |
| the original session url! */ |
| if (! svn_string_compare (sbaton->repos_path, switch_repos_path)) |
| return svn_error_createf (SVN_ERR_RA_ILLEGAL_URL, 0, NULL, sbaton->pool, |
| "'%s'\n" |
| "is not the same repository as\n" |
| "'%s'", switch_repos_path->data, |
| sbaton->repos_path->data); |
| |
| if (! SVN_IS_VALID_REVNUM(update_revision)) |
| SVN_ERR (svn_ra_local__get_latest_revnum (sbaton, &revnum_to_update_to)); |
| else |
| revnum_to_update_to = update_revision; |
| |
| /* Make sure the pipe editor is anchored in the same way as the |
| update editor. */ |
| |
| /* Assume that we should anchor the pipe editor on the switch path |
| directly. This is normal when switching a directory, since |
| tgt-anchor is the directory itself, and tgt-target is NULL. */ |
| pipe_anchor = svn_stringbuf_create_from_string (switch_fs_path, |
| sbaton->pool); |
| if (update_target) |
| { |
| /* If the target is defined, then we must be switching a file. |
| |
| The pipe editor needs to be anchored on the target's parent |
| directory. But here's the catch: the pipe-editor is going to |
| receive open_file(src-basename), because there's no |
| delete/add happening. Somehow the pipe-editor needs to fetch |
| the CR from *tgt*-basename. So we stash it in the |
| pipe-editor's own baton. ### do this. |
| */ |
| svn_path_remove_component (pipe_anchor); |
| } |
| |
| /* Wrap UPDATE_EDITOR with a custom "pipe" editor that pushes extra |
| 'entry' properties into the stream, whenever {open_root, |
| open_file, open_dir, add_file, add_dir} are called. */ |
| SVN_ERR (svn_ra_local__get_update_pipe_editor |
| (&pipe_editor, |
| &pipe_edit_baton, |
| update_editor, |
| update_baton, |
| sbaton, |
| pipe_anchor, |
| sbaton->pool)); |
| |
| /* Pass back our reporter */ |
| *reporter = &ra_local_reporter; |
| |
| /* Build a reporter baton. */ |
| return svn_repos_begin_report (report_baton, |
| revnum_to_update_to, |
| sbaton->username, |
| sbaton->repos, |
| sbaton->fs_path->data, |
| target, |
| switch_fs_path->data, |
| TRUE, /* we want text-deltas */ |
| recurse, |
| pipe_editor, pipe_edit_baton, |
| sbaton->pool); |
| } |
| |
| |
| |
| static svn_error_t * |
| svn_ra_local__do_status (void *session_baton, |
| const svn_ra_reporter_t **reporter, |
| void **report_baton, |
| svn_stringbuf_t *status_target, |
| svn_boolean_t recurse, |
| const svn_delta_edit_fns_t *status_editor, |
| void *status_baton) |
| { |
| svn_revnum_t revnum_to_update_to; |
| svn_stringbuf_t *switch_path; |
| svn_ra_local__session_baton_t *sbaton = session_baton; |
| |
| /* ### fix the status_target param at some point */ |
| const char *target; |
| target = status_target ? status_target->data : NULL; |
| |
| /* We want dir_delta to run on -identical- fs paths. */ |
| switch_path = |
| svn_stringbuf_create_from_string (sbaton->fs_path, sbaton->pool); |
| if (target) |
| svn_path_add_component_nts (switch_path, target); |
| |
| SVN_ERR (svn_ra_local__get_latest_revnum (sbaton, &revnum_to_update_to)); |
| |
| /* Pass back our reporter */ |
| *reporter = &ra_local_reporter; |
| |
| /* Build a reporter baton. */ |
| return svn_repos_begin_report (report_baton, |
| revnum_to_update_to, |
| sbaton->username, |
| sbaton->repos, |
| sbaton->fs_path->data, |
| target, |
| switch_path->data, |
| FALSE, /* don't send text-deltas */ |
| recurse, |
| status_editor, status_baton, |
| sbaton->pool); |
| } |
| |
| |
| static svn_error_t * |
| svn_ra_local__get_log (void *session_baton, |
| const apr_array_header_t *paths, |
| svn_revnum_t start, |
| svn_revnum_t end, |
| svn_boolean_t discover_changed_paths, |
| svn_log_message_receiver_t receiver, |
| void *receiver_baton) |
| { |
| svn_ra_local__session_baton_t *sbaton = session_baton; |
| apr_array_header_t *abs_paths |
| = apr_array_make (sbaton->pool, paths->nelts, sizeof (svn_stringbuf_t *)); |
| int i; |
| |
| for (i = 0; i < paths->nelts; i++) |
| { |
| svn_stringbuf_t *relative_path |
| = (((svn_stringbuf_t **)(paths)->elts)[i]); |
| |
| svn_stringbuf_t *abs_path |
| = svn_stringbuf_create_from_string (sbaton->fs_path, sbaton->pool); |
| |
| /* ### Not sure if this counts as a workaround or not. The |
| session baton uses the empty string to mean root, and not |
| sure that should change. However, it would be better to use |
| a path library function to add this separator -- hardcoding |
| it is totally bogus. See issue #559, though it may be only |
| tangentially related. */ |
| if (abs_path->len == 0) |
| svn_stringbuf_appendcstr (abs_path, "/"); |
| |
| svn_path_add_component (abs_path, relative_path); |
| (*((svn_stringbuf_t **)(apr_array_push (abs_paths)))) = abs_path; |
| } |
| |
| return svn_repos_get_logs (sbaton->repos, |
| abs_paths, |
| start, |
| end, |
| discover_changed_paths, |
| receiver, |
| receiver_baton, |
| sbaton->pool); |
| } |
| |
| |
| static svn_error_t * |
| svn_ra_local__do_check_path (svn_node_kind_t *kind, |
| void *session_baton, |
| const char *path, |
| svn_revnum_t revision) |
| { |
| svn_ra_local__session_baton_t *sbaton = session_baton; |
| svn_fs_root_t *root; |
| svn_stringbuf_t *abs_path |
| = svn_stringbuf_create_from_string (sbaton->fs_path, sbaton->pool); |
| |
| /* ### Not sure if this counts as a workaround or not. The |
| session baton uses the empty string to mean root, and not |
| sure that should change. However, it would be better to use |
| a path library function to add this separator -- hardcoding |
| it is totally bogus. See issue #559, though it may be only |
| tangentially related. */ |
| if (abs_path->len == 0) |
| svn_stringbuf_appendcstr (abs_path, "/"); |
| |
| /* If we were given a relative path to append, append it. */ |
| if (path) |
| svn_path_add_component_nts (abs_path, path); |
| |
| if (! SVN_IS_VALID_REVNUM (revision)) |
| SVN_ERR (svn_fs_youngest_rev (&revision, sbaton->fs, sbaton->pool)); |
| SVN_ERR (svn_fs_revision_root (&root, sbaton->fs, revision, sbaton->pool)); |
| *kind = svn_fs_check_path (root, abs_path->data, sbaton->pool); |
| return SVN_NO_ERROR; |
| } |
| |
| |
| |
| /* Getting just one file. */ |
| static svn_error_t * |
| svn_ra_local__get_file (void *session_baton, |
| const char *path, |
| svn_revnum_t revision, |
| svn_stream_t *stream, |
| svn_revnum_t *fetched_rev, |
| apr_hash_t **props) |
| { |
| svn_fs_root_t *root; |
| svn_stream_t *contents; |
| svn_revnum_t youngest_rev; |
| char buf[SVN_STREAM_CHUNK_SIZE]; |
| apr_size_t rlen, wlen; |
| svn_ra_local__session_baton_t *sbaton = session_baton; |
| |
| svn_stringbuf_t *abs_path |
| = svn_stringbuf_create_from_string (sbaton->fs_path, sbaton->pool); |
| |
| /* ### Not sure if this counts as a workaround or not. The |
| session baton uses the empty string to mean root, and not |
| sure that should change. However, it would be better to use |
| a path library function to add this separator -- hardcoding |
| it is totally bogus. See issue #559, though it may be only |
| tangentially related. */ |
| if (abs_path->len == 0) |
| svn_stringbuf_appendcstr (abs_path, "/"); |
| |
| /* If we were given a relative path to append, append it. */ |
| if (path) |
| svn_path_add_component_nts (abs_path, path); |
| |
| /* Open the revision's root. */ |
| if (! SVN_IS_VALID_REVNUM (revision)) |
| { |
| SVN_ERR (svn_fs_youngest_rev (&youngest_rev, sbaton->fs, sbaton->pool)); |
| SVN_ERR (svn_fs_revision_root (&root, sbaton->fs, |
| youngest_rev, sbaton->pool)); |
| if (fetched_rev != NULL) |
| *fetched_rev = youngest_rev; |
| } |
| else |
| SVN_ERR (svn_fs_revision_root (&root, sbaton->fs, |
| revision, sbaton->pool)); |
| |
| /* Get a stream representing the file's contents. */ |
| SVN_ERR (svn_fs_file_contents (&contents, root, |
| abs_path->data, sbaton->pool)); |
| |
| /* Now push data from the fs stream back at the caller's stream. */ |
| while (1) |
| { |
| /* read a maximum number of bytes from the file, please. */ |
| rlen = SVN_STREAM_CHUNK_SIZE; |
| SVN_ERR (svn_stream_read (contents, buf, &rlen)); |
| |
| /* write however many bytes you read, please. */ |
| wlen = rlen; |
| SVN_ERR (svn_stream_write (stream, buf, &wlen)); |
| if (wlen != rlen) |
| { |
| /* Uh oh, didn't write as many bytes as we read, and no |
| error was returned. According to the docstring, this |
| should never happen. */ |
| return |
| svn_error_create (SVN_ERR_UNEXPECTED_EOF, 0, NULL, |
| sbaton->pool, "Error writing to svn_stream."); |
| } |
| |
| if (rlen != SVN_STREAM_CHUNK_SIZE) |
| { |
| /* svn_stream_read didn't throw an error, yet it didn't read |
| all the bytes requested. According to the docstring, |
| this means a plain old EOF happened, so we're done. */ |
| break; |
| } |
| } |
| |
| if (props) |
| { |
| svn_revnum_t committed_rev; |
| svn_string_t *committed_date, *last_author; |
| svn_stringbuf_t *value; |
| svn_string_t *abs_path_s; |
| char *revision_str = NULL; |
| |
| /* Create a hash with props attached to the fs node. */ |
| SVN_ERR (svn_fs_node_proplist (props, root, abs_path->data, |
| sbaton->pool)); |
| |
| /* Now add some non-tweakable metadata to the hash as well... */ |
| |
| /* The so-called 'entryprops' with info about CR & friends. */ |
| abs_path_s = svn_string_create_from_buf (abs_path, sbaton->pool); |
| SVN_ERR (svn_repos_get_committed_info (&committed_rev, |
| &committed_date, |
| &last_author, |
| root, abs_path_s, |
| sbaton->pool)); |
| |
| |
| revision_str = apr_psprintf (sbaton->pool, "%ld", committed_rev); |
| value = svn_stringbuf_create (revision_str, sbaton->pool); |
| apr_hash_set (*props, SVN_PROP_ENTRY_COMMITTED_REV, |
| APR_HASH_KEY_STRING, value); |
| |
| if (committed_date) |
| value = svn_stringbuf_create_from_string (committed_date, |
| sbaton->pool); |
| else |
| value = NULL; |
| apr_hash_set (*props, SVN_PROP_ENTRY_COMMITTED_DATE, |
| APR_HASH_KEY_STRING, value); |
| |
| if (last_author) |
| value = svn_stringbuf_create_from_string (last_author, sbaton->pool); |
| else |
| value = NULL; |
| apr_hash_set (*props, SVN_PROP_ENTRY_LAST_AUTHOR, |
| APR_HASH_KEY_STRING, value); |
| |
| /* We have no 'wcprops' in ra_local, but might someday. */ |
| } |
| return SVN_NO_ERROR; |
| } |
| |
| |
| /*----------------------------------------------------------------*/ |
| |
| /** The ra_plugin **/ |
| |
| static const svn_ra_plugin_t ra_local_plugin = |
| { |
| "ra_local", |
| "Module for accessing a repository on local disk.", |
| svn_ra_local__open, |
| svn_ra_local__close, |
| svn_ra_local__get_latest_revnum, |
| svn_ra_local__get_dated_revision, |
| svn_ra_local__get_commit_editor, |
| svn_ra_local__get_file, |
| svn_ra_local__do_checkout, |
| svn_ra_local__do_update, |
| svn_ra_local__do_switch, |
| svn_ra_local__do_status, |
| NULL, |
| svn_ra_local__get_log, |
| svn_ra_local__do_check_path |
| }; |
| |
| |
| /*----------------------------------------------------------------*/ |
| |
| /** The One Public Routine, called by libsvn_client **/ |
| |
| svn_error_t * |
| svn_ra_local_init (int abi_version, |
| apr_pool_t *pool, |
| apr_hash_t *hash) |
| { |
| apr_hash_set (hash, "file", APR_HASH_KEY_STRING, &ra_local_plugin); |
| |
| /* ben sez: todo: check that abi_version >=1. */ |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| |
| |
| |
| |
| |
| |
| /* ---------------------------------------------------------------- |
| * local variables: |
| * eval: (load-file "../../tools/dev/svn-dev.el") |
| * end: |
| */ |
