diff options
Diffstat (limited to 'subversion/svnfsfs/svnfsfs.c')
| -rw-r--r-- | subversion/svnfsfs/svnfsfs.c | 541 |
1 files changed, 541 insertions, 0 deletions
diff --git a/subversion/svnfsfs/svnfsfs.c b/subversion/svnfsfs/svnfsfs.c new file mode 100644 index 0000000..f8b1e4b --- /dev/null +++ b/subversion/svnfsfs/svnfsfs.c @@ -0,0 +1,541 @@ +/* + * svnfsfs.c: FSFS repository manipulation tool main file. + * + * ==================================================================== + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + * ==================================================================== + */ + +#include <apr_signal.h> + +#include "svn_pools.h" +#include "svn_cmdline.h" +#include "svn_opt.h" +#include "svn_utf.h" +#include "svn_path.h" +#include "svn_dirent_uri.h" +#include "svn_repos.h" +#include "svn_cache_config.h" +#include "svn_version.h" + +#include "private/svn_cmdline_private.h" + +#include "svn_private_config.h" + +#include "svnfsfs.h" + + +/*** Code. ***/ + +/* A flag to see if we've been cancelled by the client or not. */ +static volatile sig_atomic_t cancelled = FALSE; + +/* A signal handler to support cancellation. */ +static void +signal_handler(int signum) +{ + apr_signal(signum, SIG_IGN); + cancelled = TRUE; +} + + +/* A helper to set up the cancellation signal handlers. */ +static void +setup_cancellation_signals(void (*handler)(int signum)) +{ + apr_signal(SIGINT, handler); +#ifdef SIGBREAK + /* SIGBREAK is a Win32 specific signal generated by ctrl-break. */ + apr_signal(SIGBREAK, handler); +#endif +#ifdef SIGHUP + apr_signal(SIGHUP, handler); +#endif +#ifdef SIGTERM + apr_signal(SIGTERM, handler); +#endif +} + + +svn_error_t * +check_cancel(void *baton) +{ + if (cancelled) + return svn_error_create(SVN_ERR_CANCELLED, NULL, _("Caught signal")); + else + return SVN_NO_ERROR; +} + + +/* Custom filesystem warning function. */ +static void +warning_func(void *baton, + svn_error_t *err) +{ + if (! err) + return; + svn_handle_warning2(stderr, err, "svnfsfs: "); +} + + +/* Version compatibility check */ +static svn_error_t * +check_lib_versions(void) +{ + static const svn_version_checklist_t checklist[] = + { + { "svn_subr", svn_subr_version }, + { "svn_repos", svn_repos_version }, + { "svn_fs", svn_fs_version }, + { "svn_delta", svn_delta_version }, + { NULL, NULL } + }; + SVN_VERSION_DEFINE(my_version); + + return svn_ver_check_list2(&my_version, checklist, svn_ver_equal); +} + + + +/** Subcommands. **/ + +enum svnfsfs__cmdline_options_t + { + svnfsfs__version = SVN_OPT_FIRST_LONGOPT_ID + }; + +/* Option codes and descriptions. + * + * The entire list must be terminated with an entry of nulls. + */ +static const apr_getopt_option_t options_table[] = + { + {"help", 'h', 0, + N_("show help on a subcommand")}, + + {NULL, '?', 0, + N_("show help on a subcommand")}, + + {"version", svnfsfs__version, 0, + N_("show program version information")}, + + {"quiet", 'q', 0, + N_("no progress (only errors to stderr)")}, + + {"revision", 'r', 1, + N_("specify revision number ARG (or X:Y range)")}, + + {"memory-cache-size", 'M', 1, + N_("size of the extra in-memory cache in MB used to\n" + " minimize redundant operations. Default: 16.")}, + + {NULL} + }; + + +/* Array of available subcommands. + * The entire list must be terminated with an entry of nulls. + */ +static const svn_opt_subcommand_desc2_t cmd_table[] = +{ + {"help", subcommand__help, {"?", "h"}, N_ + ("usage: svnfsfs help [SUBCOMMAND...]\n\n" + "Describe the usage of this program or its subcommands.\n"), + {0} }, + + {"dump-index", subcommand__dump_index, {0}, N_ + ("usage: svnfsfs dump-index REPOS_PATH -r REV\n\n" + "Dump the index contents for the revision / pack file containing revision REV\n" + "to console. This is only available for FSFS format 7 (SVN 1.9+) repositories.\n" + "The table produced contains a header in the first line followed by one line\n" + "per index entry, ordered by location in the revision / pack file. Columns:\n\n" + " * Byte offset (hex) at which the item starts\n" + " * Length (hex) of the item in bytes\n" + " * Item type (string) is one of the following:\n\n" + " none ... Unused section. File contents shall be NULs.\n" + " frep ... File representation.\n" + " drep ... Directory representation.\n" + " fprop .. File property.\n" + " dprop .. Directory property.\n" + " node ... Node revision.\n" + " chgs ... Changed paths list.\n" + " rep .... Representation of unknown type. Should not be used.\n" + " ??? .... Invalid. Index data is corrupt.\n\n" + " The distinction between frep, drep, fprop and dprop is a mere internal\n" + " classification used for various optimizations and does not affect the\n" + " operational correctness.\n\n" + " * Revision that the item belongs to (decimal)\n" + " * Item number (decimal) within that revision\n" + " * Modified FNV1a checksum (8 hex digits)\n"), + {'r', 'M'} }, + + {"load-index", subcommand__load_index, {0}, N_ + ("usage: svnfsfs load-index REPOS_PATH\n\n" + "Read index contents from console. The format is the same as produced by the\n" + "dump-index command, except that checksum as well as header are optional and will\n" + "be ignored. The data must cover the full revision / pack file; the revision\n" + "number is automatically extracted from input stream. No ordering is required.\n"), + {'M'} }, + + {"stats", subcommand__stats, {0}, N_ + ("usage: svnfsfs stats REPOS_PATH\n\n" + "Write object size statistics to console.\n"), + {'M'} }, + + { NULL, NULL, {0}, NULL, {0} } +}; + + +svn_error_t * +open_fs(svn_fs_t **fs, + const char *path, + apr_pool_t *pool) +{ + const char *fs_type; + + /* Verify that we can handle the repository type. */ + path = svn_dirent_join(path, "db", pool); + SVN_ERR(svn_fs_type(&fs_type, path, pool)); + if (strcmp(fs_type, SVN_FS_TYPE_FSFS)) + return svn_error_createf(SVN_ERR_FS_UNSUPPORTED_TYPE, NULL, + _("%s repositories are not supported"), + fs_type); + + /* Now open it. */ + SVN_ERR(svn_fs_open2(fs, path, NULL, pool, pool)); + svn_fs_set_warning_func(*fs, warning_func, NULL); + + return SVN_NO_ERROR; +} + +/* This implements `svn_opt_subcommand_t'. */ +svn_error_t * +subcommand__help(apr_getopt_t *os, void *baton, apr_pool_t *pool) +{ + svnfsfs__opt_state *opt_state = baton; + const char *header = + _("general usage: svnfsfs SUBCOMMAND REPOS_PATH [ARGS & OPTIONS ...]\n" + "Subversion FSFS repository manipulation tool.\n" + "Type 'svnfsfs help <subcommand>' for help on a specific subcommand.\n" + "Type 'svnfsfs --version' to see the program version.\n" + "\n" + "Available subcommands:\n"); + + SVN_ERR(svn_opt_print_help4(os, "svnfsfs", + opt_state ? opt_state->version : FALSE, + opt_state ? opt_state->quiet : FALSE, + /*###opt_state ? opt_state->verbose :*/ FALSE, + NULL, + header, cmd_table, options_table, NULL, NULL, + pool)); + + return SVN_NO_ERROR; +} + + +/** Main. **/ + +/* + * On success, leave *EXIT_CODE untouched and return SVN_NO_ERROR. On error, + * either return an error to be displayed, or set *EXIT_CODE to non-zero and + * return SVN_NO_ERROR. + */ +static svn_error_t * +sub_main(int *exit_code, int argc, const char *argv[], apr_pool_t *pool) +{ + svn_error_t *err; + apr_status_t apr_err; + + const svn_opt_subcommand_desc2_t *subcommand = NULL; + svnfsfs__opt_state opt_state = { 0 }; + apr_getopt_t *os; + int opt_id; + apr_array_header_t *received_opts; + int i; + + received_opts = apr_array_make(pool, SVN_OPT_MAX_OPTIONS, sizeof(int)); + + /* Check library versions */ + SVN_ERR(check_lib_versions()); + + /* Initialize the FS library. */ + SVN_ERR(svn_fs_initialize(pool)); + + if (argc <= 1) + { + SVN_ERR(subcommand__help(NULL, NULL, pool)); + *exit_code = EXIT_FAILURE; + return SVN_NO_ERROR; + } + + /* Initialize opt_state. */ + opt_state.start_revision.kind = svn_opt_revision_unspecified; + opt_state.end_revision.kind = svn_opt_revision_unspecified; + opt_state.memory_cache_size = svn_cache_config_get()->cache_size; + + /* Parse options. */ + SVN_ERR(svn_cmdline__getopt_init(&os, argc, argv, pool)); + + os->interleave = 1; + + while (1) + { + const char *opt_arg; + const char *utf8_opt_arg; + + /* Parse the next option. */ + apr_err = apr_getopt_long(os, options_table, &opt_id, &opt_arg); + if (APR_STATUS_IS_EOF(apr_err)) + break; + else if (apr_err) + { + SVN_ERR(subcommand__help(NULL, NULL, pool)); + *exit_code = EXIT_FAILURE; + return SVN_NO_ERROR; + } + + /* Stash the option code in an array before parsing it. */ + APR_ARRAY_PUSH(received_opts, int) = opt_id; + + switch (opt_id) { + case 'r': + { + if (opt_state.start_revision.kind != svn_opt_revision_unspecified) + { + return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL, + _("Multiple revision arguments encountered; " + "try '-r N:M' instead of '-r N -r M'")); + } + if (svn_opt_parse_revision(&(opt_state.start_revision), + &(opt_state.end_revision), + opt_arg, pool) != 0) + { + SVN_ERR(svn_utf_cstring_to_utf8(&utf8_opt_arg, opt_arg, pool)); + + return svn_error_createf(SVN_ERR_CL_ARG_PARSING_ERROR, NULL, + _("Syntax error in revision argument '%s'"), + utf8_opt_arg); + } + } + break; + case 'q': + opt_state.quiet = TRUE; + break; + case 'h': + case '?': + opt_state.help = TRUE; + break; + case 'M': + opt_state.memory_cache_size + = 0x100000 * apr_strtoi64(opt_arg, NULL, 0); + break; + case svnfsfs__version: + opt_state.version = TRUE; + break; + default: + { + SVN_ERR(subcommand__help(NULL, NULL, pool)); + *exit_code = EXIT_FAILURE; + return SVN_NO_ERROR; + } + } /* close `switch' */ + } /* close `while' */ + + /* If the user asked for help, then the rest of the arguments are + the names of subcommands to get help on (if any), or else they're + just typos/mistakes. Whatever the case, the subcommand to + actually run is subcommand_help(). */ + if (opt_state.help) + subcommand = svn_opt_get_canonical_subcommand2(cmd_table, "help"); + + /* If we're not running the `help' subcommand, then look for a + subcommand in the first argument. */ + if (subcommand == NULL) + { + if (os->ind >= os->argc) + { + if (opt_state.version) + { + /* Use the "help" subcommand to handle the "--version" option. */ + static const svn_opt_subcommand_desc2_t pseudo_cmd = + { "--version", subcommand__help, {0}, "", + {svnfsfs__version, /* must accept its own option */ + 'q', /* --quiet */ + } }; + + subcommand = &pseudo_cmd; + } + else + { + svn_error_clear(svn_cmdline_fprintf(stderr, pool, + _("subcommand argument required\n"))); + SVN_ERR(subcommand__help(NULL, NULL, pool)); + *exit_code = EXIT_FAILURE; + return SVN_NO_ERROR; + } + } + else + { + const char *first_arg = os->argv[os->ind++]; + subcommand = svn_opt_get_canonical_subcommand2(cmd_table, first_arg); + if (subcommand == NULL) + { + const char *first_arg_utf8; + SVN_ERR(svn_utf_cstring_to_utf8(&first_arg_utf8, + first_arg, pool)); + svn_error_clear( + svn_cmdline_fprintf(stderr, pool, + _("Unknown subcommand: '%s'\n"), + first_arg_utf8)); + SVN_ERR(subcommand__help(NULL, NULL, pool)); + *exit_code = EXIT_FAILURE; + return SVN_NO_ERROR; + } + } + } + + /* Every subcommand except `help' requires a second argument -- the + repository path. Parse it out here and store it in opt_state. */ + if (!(subcommand->cmd_func == subcommand__help)) + { + const char *repos_path = NULL; + + if (os->ind >= os->argc) + { + return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL, + _("Repository argument required")); + } + + SVN_ERR(svn_utf_cstring_to_utf8(&repos_path, os->argv[os->ind++], pool)); + + if (svn_path_is_url(repos_path)) + { + return svn_error_createf(SVN_ERR_CL_ARG_PARSING_ERROR, NULL, + _("'%s' is a URL when it should be a " + "local path"), repos_path); + } + + opt_state.repository_path = svn_dirent_internal_style(repos_path, pool); + } + + /* Check that the subcommand wasn't passed any inappropriate options. */ + for (i = 0; i < received_opts->nelts; i++) + { + opt_id = APR_ARRAY_IDX(received_opts, i, int); + + /* All commands implicitly accept --help, so just skip over this + when we see it. Note that we don't want to include this option + in their "accepted options" list because it would be awfully + redundant to display it in every commands' help text. */ + if (opt_id == 'h' || opt_id == '?') + continue; + + if (! svn_opt_subcommand_takes_option3(subcommand, opt_id, NULL)) + { + const char *optstr; + const apr_getopt_option_t *badopt = + svn_opt_get_option_from_code2(opt_id, options_table, subcommand, + pool); + svn_opt_format_option(&optstr, badopt, FALSE, pool); + if (subcommand->name[0] == '-') + SVN_ERR(subcommand__help(NULL, NULL, pool)); + else + svn_error_clear(svn_cmdline_fprintf(stderr, pool + , _("Subcommand '%s' doesn't accept option '%s'\n" + "Type 'svnfsfs help %s' for usage.\n"), + subcommand->name, optstr, subcommand->name)); + *exit_code = EXIT_FAILURE; + return SVN_NO_ERROR; + } + } + + /* Set up our cancellation support. */ + setup_cancellation_signals(signal_handler); + +#ifdef SIGPIPE + /* Disable SIGPIPE generation for the platforms that have it. */ + apr_signal(SIGPIPE, SIG_IGN); +#endif + +#ifdef SIGXFSZ + /* Disable SIGXFSZ generation for the platforms that have it, otherwise + * working with large files when compiled against an APR that doesn't have + * large file support will crash the program, which is uncool. */ + apr_signal(SIGXFSZ, SIG_IGN); +#endif + + /* Configure FSFS caches for maximum efficiency with svnfsfs. + * Also, apply the respective command line parameters, if given. */ + { + svn_cache_config_t settings = *svn_cache_config_get(); + + settings.cache_size = opt_state.memory_cache_size; + settings.single_threaded = TRUE; + + svn_cache_config_set(&settings); + } + + /* Run the subcommand. */ + err = (*subcommand->cmd_func)(os, &opt_state, pool); + if (err) + { + /* For argument-related problems, suggest using the 'help' + subcommand. */ + if (err->apr_err == SVN_ERR_CL_INSUFFICIENT_ARGS + || err->apr_err == SVN_ERR_CL_ARG_PARSING_ERROR) + { + err = svn_error_quick_wrap(err, + _("Try 'svnfsfs help' for more info")); + } + return err; + } + + return SVN_NO_ERROR; +} + +int +main(int argc, const char *argv[]) +{ + apr_pool_t *pool; + int exit_code = EXIT_SUCCESS; + svn_error_t *err; + + /* Initialize the app. */ + if (svn_cmdline_init("svnfsfs", stderr) != EXIT_SUCCESS) + return EXIT_FAILURE; + + /* Create our top-level pool. Use a separate mutexless allocator, + * given this application is single threaded. + */ + pool = apr_allocator_owner_get(svn_pool_create_allocator(FALSE)); + + err = sub_main(&exit_code, argc, argv, pool); + + /* Flush stdout and report if it fails. It would be flushed on exit anyway + but this makes sure that output is not silently lost if it fails. */ + err = svn_error_compose_create(err, svn_cmdline_fflush(stdout)); + + if (err) + { + exit_code = EXIT_FAILURE; + svn_cmdline_handle_exit_error(err, NULL, "svnfsfs: "); + } + + svn_pool_destroy(pool); + return exit_code; +} |