static svn_error_t *
write_indent(struct edit_baton *eb, apr_pool_t *pool)
{
int i;
/* This is DBG_FLAG from ../libsvn_subr/debug.c */
SVN_ERR(svn_stream_puts(eb->out, "DBG:"));
for (i = 0; i < eb->indent_level; ++i)
SVN_ERR(svn_stream_puts(eb->out, " "));
return SVN_NO_ERROR;
}
svn_error_t *
svn_diff_output_binary(svn_stream_t *output_stream,
svn_stream_t *original,
svn_stream_t *latest,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *scratch_pool)
{
apr_file_t *original_apr;
svn_filesize_t original_full;
svn_filesize_t original_deflated;
apr_file_t *latest_apr;
svn_filesize_t latest_full;
svn_filesize_t latest_deflated;
apr_pool_t *subpool = svn_pool_create(scratch_pool);
SVN_ERR(create_compressed(&original_apr, &original_full, &original_deflated,
original, cancel_func, cancel_baton,
scratch_pool, subpool));
svn_pool_clear(subpool);
SVN_ERR(create_compressed(&latest_apr, &latest_full, &latest_deflated,
latest, cancel_func, cancel_baton,
scratch_pool, subpool));
svn_pool_clear(subpool);
SVN_ERR(svn_stream_puts(output_stream, "GIT binary patch" APR_EOL_STR));
/* ### git would first calculate if a git-delta latest->original would be
shorter than the zipped data. For now lets assume that it is not
and just dump the literal data */
SVN_ERR(write_literal(latest_full,
svn_stream_from_aprfile2(latest_apr, FALSE, subpool),
output_stream,
cancel_func, cancel_baton,
scratch_pool));
svn_pool_clear(subpool);
SVN_ERR(svn_stream_puts(output_stream, APR_EOL_STR));
/* ### git would first calculate if a git-delta original->latest would be
shorter than the zipped data. For now lets assume that it is not
and just dump the literal data */
SVN_ERR(write_literal(original_full,
svn_stream_from_aprfile2(original_apr, FALSE, subpool),
output_stream,
cancel_func, cancel_baton,
scratch_pool));
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_fs__write_rep_header(svn_fs_fs__rep_header_t *header,
svn_stream_t *stream,
apr_pool_t *scratch_pool)
{
const char *text;
switch (header->type)
{
case svn_fs_fs__rep_plain:
text = REP_PLAIN "\n";
break;
case svn_fs_fs__rep_self_delta:
text = REP_DELTA "\n";
break;
default:
text = apr_psprintf(scratch_pool, REP_DELTA " %ld %" APR_OFF_T_FMT
" %" SVN_FILESIZE_T_FMT "\n",
header->base_revision, header->base_item_index,
header->base_length);
}
return svn_error_trace(svn_stream_puts(stream, text));
}
static svn_error_t *
finish_report(void *report_baton,
apr_pool_t *pool)
{
struct report_baton *rb = report_baton;
SVN_ERR(svn_stream_puts(rb->out, "finish_report()\n"));
SVN_ERR(rb->wrapped_reporter->finish_report(rb->wrapped_report_baton, pool));
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_fs__write_changes(svn_stream_t *stream,
svn_fs_t *fs,
apr_hash_t *changes,
svn_boolean_t terminate_list,
apr_pool_t *scratch_pool)
{
apr_pool_t *iterpool = svn_pool_create(scratch_pool);
fs_fs_data_t *ffd = fs->fsap_data;
svn_boolean_t include_node_kinds =
ffd->format >= SVN_FS_FS__MIN_KIND_IN_CHANGED_FORMAT;
svn_boolean_t include_mergeinfo_mods =
ffd->format >= SVN_FS_FS__MIN_MERGEINFO_IN_CHANGED_FORMAT;
apr_array_header_t *sorted_changed_paths;
int i;
/* For the sake of the repository administrator sort the changes so
that the final file is deterministic and repeatable, however the
rest of the FSFS code doesn't require any particular order here.
Also, this sorting is only effective in writing all entries with
a single call as write_final_changed_path_info() does. For the
list being written incrementally during transaction, we actually
*must not* change the order of entries from different calls.
*/
sorted_changed_paths = svn_sort__hash(changes,
svn_sort_compare_items_lexically,
scratch_pool);
/* Write all items to disk in the new order. */
for (i = 0; i < sorted_changed_paths->nelts; ++i)
{
svn_fs_path_change2_t *change;
const char *path;
svn_pool_clear(iterpool);
change = APR_ARRAY_IDX(sorted_changed_paths, i, svn_sort__item_t).value;
path = APR_ARRAY_IDX(sorted_changed_paths, i, svn_sort__item_t).key;
/* Write out the new entry into the final rev-file. */
SVN_ERR(write_change_entry(stream, path, change, include_node_kinds,
include_mergeinfo_mods, iterpool));
}
if (terminate_list)
svn_stream_puts(stream, "\n");
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
svn_error_t *
svn_stream_printf(svn_stream_t *stream,
apr_pool_t *pool,
const char *fmt,
...)
{
const char *message;
va_list ap;
va_start(ap, fmt);
message = apr_pvsprintf(pool, fmt, ap);
va_end(ap);
return svn_error_trace(svn_stream_puts(stream, message));
}
svn_error_t *
svn_stream_printf_from_utf8(svn_stream_t *stream,
const char *encoding,
apr_pool_t *pool,
const char *fmt,
...)
{
const char *message, *translated;
va_list ap;
va_start(ap, fmt);
message = apr_pvsprintf(pool, fmt, ap);
va_end(ap);
SVN_ERR(svn_utf_cstring_from_utf8_ex2(&translated, message, encoding,
pool));
return svn_error_trace(svn_stream_puts(stream, translated));
}
svn_error_t *
svn_fs_fs__write_noderev(svn_stream_t *outfile,
node_revision_t *noderev,
int format,
svn_boolean_t include_mergeinfo,
apr_pool_t *scratch_pool)
{
SVN_ERR(svn_stream_printf(outfile, scratch_pool, HEADER_ID ": %s\n",
svn_fs_fs__id_unparse(noderev->id,
scratch_pool)->data));
SVN_ERR(svn_stream_printf(outfile, scratch_pool, HEADER_TYPE ": %s\n",
(noderev->kind == svn_node_file) ?
SVN_FS_FS__KIND_FILE : SVN_FS_FS__KIND_DIR));
if (noderev->predecessor_id)
SVN_ERR(svn_stream_printf(outfile, scratch_pool, HEADER_PRED ": %s\n",
svn_fs_fs__id_unparse(noderev->predecessor_id,
scratch_pool)->data));
SVN_ERR(svn_stream_printf(outfile, scratch_pool, HEADER_COUNT ": %d\n",
noderev->predecessor_count));
if (noderev->data_rep)
SVN_ERR(svn_stream_printf(outfile, scratch_pool, HEADER_TEXT ": %s\n",
svn_fs_fs__unparse_representation
(noderev->data_rep,
format,
noderev->kind == svn_node_dir,
scratch_pool, scratch_pool)->data));
if (noderev->prop_rep)
SVN_ERR(svn_stream_printf(outfile, scratch_pool, HEADER_PROPS ": %s\n",
svn_fs_fs__unparse_representation
(noderev->prop_rep, format,
TRUE, scratch_pool, scratch_pool)->data));
SVN_ERR(svn_stream_printf(outfile, scratch_pool, HEADER_CPATH ": %s\n",
noderev->created_path));
if (noderev->copyfrom_path)
SVN_ERR(svn_stream_printf(outfile, scratch_pool, HEADER_COPYFROM ": %ld"
" %s\n",
noderev->copyfrom_rev,
noderev->copyfrom_path));
if ((noderev->copyroot_rev != svn_fs_fs__id_rev(noderev->id)) ||
(strcmp(noderev->copyroot_path, noderev->created_path) != 0))
SVN_ERR(svn_stream_printf(outfile, scratch_pool, HEADER_COPYROOT ": %ld"
" %s\n",
noderev->copyroot_rev,
noderev->copyroot_path));
if (noderev->is_fresh_txn_root)
SVN_ERR(svn_stream_puts(outfile, HEADER_FRESHTXNRT ": y\n"));
if (include_mergeinfo)
{
if (noderev->mergeinfo_count > 0)
SVN_ERR(svn_stream_printf(outfile, scratch_pool, HEADER_MINFO_CNT
": %" APR_INT64_T_FMT "\n",
noderev->mergeinfo_count));
if (noderev->has_mergeinfo)
SVN_ERR(svn_stream_puts(outfile, HEADER_MINFO_HERE ": y\n"));
}
return svn_stream_puts(outfile, "\n");
}
/* Writes out a git-like literal output of the compressed data in
COMPRESSED_DATA to OUTPUT_STREAM, describing that its normal length is
UNCOMPRESSED_SIZE. */
static svn_error_t *
write_literal(svn_filesize_t uncompressed_size,
svn_stream_t *compressed_data,
svn_stream_t *output_stream,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *scratch_pool)
{
apr_size_t rd;
SVN_ERR(svn_stream_seek(compressed_data, NULL)); /* Seek to start */
SVN_ERR(svn_stream_printf(output_stream, scratch_pool,
"literal %" SVN_FILESIZE_T_FMT APR_EOL_STR,
uncompressed_size));
do
{
char chunk[GIT_BASE85_CHUNKSIZE];
const unsigned char *next;
apr_size_t left;
rd = sizeof(chunk);
if (cancel_func)
SVN_ERR(cancel_func(cancel_baton));
SVN_ERR(svn_stream_read_full(compressed_data, chunk, &rd));
{
apr_size_t one = 1;
SVN_ERR(svn_stream_write(output_stream, &b85lenstr[rd-1], &one));
}
left = rd;
next = (void*)chunk;
while (left)
{
char five[5];
unsigned info = 0;
int n;
apr_size_t five_sz;
/* Push 4 bytes into the 32 bit info, when available */
for (n = 24; n >= 0 && left; n -= 8, next++, left--)
{
info |= (*next) << n;
}
/* Write out info as base85 */
for (n = 4; n >= 0; n--)
{
five[n] = b85str[info % 85];
info /= 85;
}
five_sz = 5;
SVN_ERR(svn_stream_write(output_stream, five, &five_sz));
}
SVN_ERR(svn_stream_puts(output_stream, APR_EOL_STR));
}
while (rd == GIT_BASE85_CHUNKSIZE);
return SVN_NO_ERROR;
}
/* Implementation of svn_repos_notify_func_t to wrap the output to a
response stream for svn_repos_dump_fs2() and svn_repos_verify_fs() */
static void
repos_notify_handler(void *baton,
const svn_repos_notify_t *notify,
apr_pool_t *scratch_pool)
{
svn_stream_t *feedback_stream = baton;
apr_size_t len;
switch (notify->action)
{
case svn_repos_notify_warning:
svn_error_clear(svn_stream_puts(feedback_stream, notify->warning_str));
return;
case svn_repos_notify_dump_rev_end:
svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
_("* Dumped revision %ld.\n"),
notify->revision));
return;
case svn_repos_notify_verify_rev_end:
svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
_("* Verified revision %ld.\n"),
notify->revision));
return;
case svn_repos_notify_load_txn_committed:
if (notify->old_revision == SVN_INVALID_REVNUM)
{
svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
_("\n------- Committed revision %ld >>>\n\n"),
notify->new_revision));
}
else
{
svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
_("\n------- Committed new rev %ld"
" (loaded from original rev %ld"
") >>>\n\n"), notify->new_revision,
notify->old_revision));
}
return;
case svn_repos_notify_load_node_start:
{
switch (notify->node_action)
{
case svn_node_action_change:
svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
_(" * editing path : %s ..."),
notify->path));
break;
case svn_node_action_delete:
svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
_(" * deleting path : %s ..."),
notify->path));
break;
case svn_node_action_add:
svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
_(" * adding path : %s ..."),
notify->path));
break;
case svn_node_action_replace:
svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
_(" * replacing path : %s ..."),
notify->path));
break;
}
}
return;
case svn_repos_notify_load_node_done:
len = 7;
svn_error_clear(svn_stream_write(feedback_stream, _(" done.\n"), &len));
return;
case svn_repos_notify_load_copied_node:
len = 9;
svn_error_clear(svn_stream_write(feedback_stream, "COPIED...", &len));
return;
case svn_repos_notify_load_txn_start:
svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
_("<<< Started new transaction, based on "
"original revision %ld\n"),
notify->old_revision));
return;
case svn_repos_notify_load_normalized_mergeinfo:
svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
_(" removing '\\r' from %s ..."),
SVN_PROP_MERGEINFO));
return;
default:
return;
}
}
svn_error_t *
svn_fs_x__write_noderev(svn_stream_t *outfile,
svn_fs_x__noderev_t *noderev,
apr_pool_t *scratch_pool)
{
svn_string_t *str_id;
str_id = svn_fs_x__id_unparse(&noderev->noderev_id, scratch_pool);
SVN_ERR(svn_stream_printf(outfile, scratch_pool, HEADER_ID ": %s\n",
str_id->data));
str_id = svn_fs_x__id_unparse(&noderev->node_id, scratch_pool);
SVN_ERR(svn_stream_printf(outfile, scratch_pool, HEADER_NODE ": %s\n",
str_id->data));
str_id = svn_fs_x__id_unparse(&noderev->copy_id, scratch_pool);
SVN_ERR(svn_stream_printf(outfile, scratch_pool, HEADER_COPY ": %s\n",
str_id->data));
SVN_ERR(svn_stream_printf(outfile, scratch_pool, HEADER_TYPE ": %s\n",
(noderev->kind == svn_node_file) ?
SVN_FS_X__KIND_FILE : SVN_FS_X__KIND_DIR));
if (svn_fs_x__id_used(&noderev->predecessor_id))
SVN_ERR(svn_stream_printf(outfile, scratch_pool, HEADER_PRED ": %s\n",
svn_fs_x__id_unparse(&noderev->predecessor_id,
scratch_pool)->data));
SVN_ERR(svn_stream_printf(outfile, scratch_pool, HEADER_COUNT ": %d\n",
noderev->predecessor_count));
if (noderev->data_rep)
SVN_ERR(svn_stream_printf(outfile, scratch_pool, HEADER_TEXT ": %s\n",
svn_fs_x__unparse_representation
(noderev->data_rep,
noderev->kind == svn_node_dir,
scratch_pool, scratch_pool)->data));
if (noderev->prop_rep)
SVN_ERR(svn_stream_printf(outfile, scratch_pool, HEADER_PROPS ": %s\n",
svn_fs_x__unparse_representation
(noderev->prop_rep,
TRUE, scratch_pool, scratch_pool)->data));
SVN_ERR(svn_stream_printf(outfile, scratch_pool, HEADER_CPATH ": %s\n",
auto_escape_path(noderev->created_path,
scratch_pool)));
if (noderev->copyfrom_path)
SVN_ERR(svn_stream_printf(outfile, scratch_pool, HEADER_COPYFROM ": %ld"
" %s\n",
noderev->copyfrom_rev,
auto_escape_path(noderev->copyfrom_path,
scratch_pool)));
if ( ( noderev->copyroot_rev
!= svn_fs_x__get_revnum(noderev->noderev_id.change_set))
|| (strcmp(noderev->copyroot_path, noderev->created_path) != 0))
SVN_ERR(svn_stream_printf(outfile, scratch_pool, HEADER_COPYROOT ": %ld"
" %s\n",
noderev->copyroot_rev,
auto_escape_path(noderev->copyroot_path,
scratch_pool)));
if (noderev->mergeinfo_count > 0)
SVN_ERR(svn_stream_printf(outfile, scratch_pool, HEADER_MINFO_CNT ": %"
APR_INT64_T_FMT "\n",
noderev->mergeinfo_count));
if (noderev->has_mergeinfo)
SVN_ERR(svn_stream_puts(outfile, HEADER_MINFO_HERE ": y\n"));
return svn_stream_puts(outfile, "\n");
}