subversion/libsvn_ra_serf/replay.c

   1 /*
   2  * replay.c :  entry point for replay RA functions for ra_serf
   3  *
   4  * ====================================================================
   5  * Copyright (c) 2006-2007 CollabNet.  All rights reserved.
   6  *
   7  * This software is licensed as described in the file COPYING, which
   8  * you should have received as part of this distribution.  The terms
   9  * are also available at http://subversion.tigris.org/license-1.html.
  10  * If newer versions of this license are posted there, you may use a
  11  * newer version instead, at your option.
  12  *
  13  * This software consists of voluntary contributions made by many
  14  * individuals.  For exact contribution history, see the revision
  15  * history and replays, available at http://subversion.tigris.org/.
  16  * ====================================================================
  17  */
  18
  19
  20 \f
  21 #include <apr_uri.h>
  22
  23 #include <expat.h>
  24
  25 #include <serf.h>
  26
  27 #include "svn_pools.h"
  28 #include "svn_ra.h"
  29 #include "svn_dav.h"
  30 #include "svn_xml.h"
  31 #include "../libsvn_ra/ra_loader.h"
  32 #include "svn_config.h"
  33 #include "svn_delta.h"
  34 #include "svn_base64.h"
  35 #include "svn_version.h"
  36 #include "svn_path.h"
  37 #include "svn_private_config.h"
  38
  39 #include "ra_serf.h"
  40
  41 \f
  42 /*
  43  * This enum represents the current state of our XML parsing.
  44  */
  45 typedef enum {
  46   NONE = 0,
  47   REPORT,
  48   OPEN_DIR,
  49   ADD_DIR,
  50   OPEN_FILE,
  51   ADD_FILE,
  52   DELETE_ENTRY,
  53   APPLY_TEXTDELTA,
  54   CHANGE_PROP,
  55 } replay_state_e;
  56
  57 typedef struct replay_info_t replay_info_t;
  58
  59 struct replay_info_t {
  60   apr_pool_t *pool;
  61
  62   void *baton;
  63   svn_stream_t *stream;
  64
  65   replay_info_t *parent;
  66 };
  67
  68 typedef svn_error_t *
  69 (*change_prop_t)(void *baton,
  70                  const char *name,
  71                  const svn_string_t *value,
  72                  apr_pool_t *pool);
  73
  74 typedef struct {
  75   apr_pool_t *pool;
  76
  77   change_prop_t change;
  78
  79   const char *name;
  80   svn_boolean_t del_prop;
  81
  82   const char *data;
  83   apr_size_t len;
  84
  85   replay_info_t *parent;
  86 } prop_info_t;
  87
  88 typedef struct {
  89   apr_pool_t *pool;
  90
  91   /* Are we done fetching this file? */
  92   svn_boolean_t done;
  93   svn_ra_serf__list_t **done_list;
  94   svn_ra_serf__list_t done_item;
  95
  96   /* callback to get an editor */
  97   svn_ra_replay_revstart_callback_t revstart_func;
  98   svn_ra_replay_revfinish_callback_t revfinish_func;
  99   void *replay_baton;
 100
 101   /* replay receiver function and baton */
 102   const svn_delta_editor_t *editor;
 103   void *editor_baton;
 104
 105   /* current revision */
 106   svn_revnum_t revision;
 107
 108   /* Information needed to create the replay report body */
 109   svn_revnum_t low_water_mark;
 110   svn_boolean_t send_deltas;
 111
 112   /* Cached vcc_url */
 113   const char *vcc_url;
 114
 115   /* Revision properties for this revision. */
 116   apr_hash_t *revs_props;
 117   apr_hash_t *props;
 118
 119 } replay_context_t;
 120
 121 \f
 122 static void *
 123 push_state(svn_ra_serf__xml_parser_t *parser,
 124            replay_context_t *replay_ctx,
 125            replay_state_e state)
 126 {
 127   svn_ra_serf__xml_push_state(parser, state);
 128
 129   if (state == OPEN_DIR || state == ADD_DIR ||
 130       state == OPEN_FILE || state == ADD_FILE)
 131     {
 132       replay_info_t *info;
 133
 134       info = apr_palloc(parser->state->pool, sizeof(*info));
 135
 136       info->pool = parser->state->pool;
 137       info->parent = parser->state->private;
 138       info->baton = NULL;
 139       info->stream = NULL;
 140
 141       parser->state->private = info;
 142     }
 143   else if (state == CHANGE_PROP)
 144     {
 145       prop_info_t *info;
 146
 147       info = apr_pcalloc(parser->state->pool, sizeof(*info));
 148
 149       info->pool = parser->state->pool;
 150       info->parent = parser->state->private;
 151
 152       parser->state->private = info;
 153     }
 154
 155   return parser->state->private;
 156 }
 157
 158 static svn_error_t *
 159 start_replay(svn_ra_serf__xml_parser_t *parser,
 160              void *userData,
 161              svn_ra_serf__dav_props_t name,
 162              const char **attrs)
 163 {
 164   replay_context_t *ctx = userData;
 165   replay_state_e state;
 166
 167   state = parser->state->current_state;
 168
 169   if (state == NONE &&
 170       strcmp(name.name, "editor-report") == 0)
 171     {
 172       push_state(parser, ctx, REPORT);
 173       ctx->props = apr_hash_make(ctx->pool);
 174
 175       svn_ra_serf__walk_all_props(ctx->revs_props, ctx->vcc_url, ctx->revision,
 176                                   svn_ra_serf__set_bare_props,
 177                                   ctx->props, ctx->pool);
 178       SVN_ERR(ctx->revstart_func(ctx->revision, ctx->replay_baton,
 179                                  &ctx->editor, &ctx->editor_baton,
 180                                  ctx->props,
 181                                  ctx->pool));
 182     }
 183   else if (state == REPORT &&
 184            strcmp(name.name, "target-revision") == 0)
 185     {
 186       const char *rev;
 187
 188       rev = svn_xml_get_attr_value("rev", attrs);
 189       if (!rev)
 190         {
 191           return svn_error_create(SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,
 192                     _("Missing revision attr in target-revision element"));
 193         }
 194
 195       SVN_ERR(ctx->editor->set_target_revision(ctx->editor_baton,
 196                                                SVN_STR_TO_REV(rev),
 197                                                parser->state->pool));
 198     }
 199   else if (state == REPORT &&
 200            strcmp(name.name, "open-root") == 0)
 201     {
 202       const char *rev;
 203       replay_info_t *info;
 204
 205       rev = svn_xml_get_attr_value("rev", attrs);
 206
 207       if (!rev)
 208         {
 209           return svn_error_create(SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,
 210                     _("Missing revision attr in open-root element"));
 211         }
 212
 213       info = push_state(parser, ctx, OPEN_DIR);
 214
 215       SVN_ERR(ctx->editor->open_root(ctx->editor_baton,
 216                                      SVN_STR_TO_REV(rev), parser->state->pool,
 217                                      &info->baton));
 218     }
 219   else if ((state == OPEN_DIR || state == ADD_DIR) &&
 220            strcmp(name.name, "delete-entry") == 0)
 221     {
 222       const char *file_name, *rev;
 223       replay_info_t *info;
 224
 225       file_name = svn_xml_get_attr_value("name", attrs);
 226       if (!file_name)
 227         {
 228           return svn_error_create(SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,
 229                     _("Missing name attr in delete-entry element"));
 230         }
 231       rev = svn_xml_get_attr_value("rev", attrs);
 232       if (!rev)
 233         {
 234           return svn_error_create(SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,
 235                     _("Missing revision attr in delete-entry element"));
 236         }
 237
 238       info = push_state(parser, ctx, DELETE_ENTRY);
 239
 240       SVN_ERR(ctx->editor->delete_entry(file_name, SVN_STR_TO_REV(rev),
 241                                         info->baton, parser->state->pool));
 242
 243       svn_ra_serf__xml_pop_state(parser);
 244     }
 245   else if ((state == OPEN_DIR || state == ADD_DIR) &&
 246            strcmp(name.name, "open-directory") == 0)
 247     {
 248       const char *rev, *dirname;
 249       replay_info_t *info;
 250
 251       dirname = svn_xml_get_attr_value("name", attrs);
 252       if (!dirname)
 253         {
 254           return svn_error_create(SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,
 255                     _("Missing name attr in open-directory element"));
 256         }
 257       rev = svn_xml_get_attr_value("rev", attrs);
 258       if (!rev)
 259         {
 260           return svn_error_create(SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,
 261                     _("Missing revision attr in open-directory element"));
 262         }
 263
 264       info = push_state(parser, ctx, OPEN_DIR);
 265
 266       SVN_ERR(ctx->editor->open_directory(dirname, info->parent->baton,
 267                                           SVN_STR_TO_REV(rev),
 268                                           parser->state->pool, &info->baton));
 269     }
 270   else if ((state == OPEN_DIR || state == ADD_DIR) &&
 271            strcmp(name.name, "add-directory") == 0)
 272     {
 273       const char *dir_name, *copyfrom, *copyrev;
 274       svn_revnum_t rev;
 275       replay_info_t *info;
 276
 277       dir_name = svn_xml_get_attr_value("name", attrs);
 278       if (!dir_name)
 279         {
 280           return svn_error_create(SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,
 281                     _("Missing name attr in add-directory element"));
 282         }
 283       copyfrom = svn_xml_get_attr_value("copyfrom-path", attrs);
 284       copyrev = svn_xml_get_attr_value("copyfrom-rev", attrs);
 285
 286       if (copyrev)
 287         rev = SVN_STR_TO_REV(copyrev);
 288       else
 289         rev = SVN_INVALID_REVNUM;
 290
 291       info = push_state(parser, ctx, ADD_DIR);
 292
 293       SVN_ERR(ctx->editor->add_directory(dir_name, info->parent->baton,
 294                                          copyfrom, rev,
 295                                          parser->state->pool, &info->baton));
 296     }
 297   else if ((state == OPEN_DIR || state == ADD_DIR) &&
 298            strcmp(name.name, "close-directory") == 0)
 299     {
 300       replay_info_t *info = parser->state->private;
 301
 302       SVN_ERR(ctx->editor->close_directory(info->baton, parser->state->pool));
 303
 304       svn_ra_serf__xml_pop_state(parser);
 305     }
 306   else if ((state == OPEN_DIR || state == ADD_DIR) &&
 307            strcmp(name.name, "open-file") == 0)
 308     {
 309       const char *file_name, *rev;
 310       replay_info_t *info;
 311
 312       file_name = svn_xml_get_attr_value("name", attrs);
 313       if (!file_name)
 314         {
 315           return svn_error_create(SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,
 316                     _("Missing name attr in open-file element"));
 317         }
 318       rev = svn_xml_get_attr_value("rev", attrs);
 319       if (!rev)
 320         {
 321           return svn_error_create(SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,
 322                     _("Missing revision attr in open-file element"));
 323         }
 324
 325       info = push_state(parser, ctx, OPEN_FILE);
 326
 327       SVN_ERR(ctx->editor->open_file(file_name, info->parent->baton,
 328                                      SVN_STR_TO_REV(rev),
 329                                      parser->state->pool, &info->baton));
 330     }
 331   else if ((state == OPEN_DIR || state == ADD_DIR) &&
 332            strcmp(name.name, "add-file") == 0)
 333     {
 334       const char *file_name, *copyfrom, *copyrev;
 335       svn_revnum_t rev;
 336       replay_info_t *info;
 337
 338       file_name = svn_xml_get_attr_value("name", attrs);
 339       if (!file_name)
 340         {
 341           return svn_error_create(SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,
 342                     _("Missing name attr in add-file element"));
 343         }
 344       copyfrom = svn_xml_get_attr_value("copyfrom-path", attrs);
 345       copyrev = svn_xml_get_attr_value("copyfrom-rev", attrs);
 346
 347       info = push_state(parser, ctx, ADD_FILE);
 348
 349       if (copyrev)
 350         rev = SVN_STR_TO_REV(copyrev);
 351       else
 352         rev = SVN_INVALID_REVNUM;
 353
 354       SVN_ERR(ctx->editor->add_file(file_name, info->parent->baton,
 355                                     copyfrom, rev,
 356                                     parser->state->pool, &info->baton));
 357     }
 358   else if ((state == OPEN_FILE || state == ADD_FILE) &&
 359            strcmp(name.name, "apply-textdelta") == 0)
 360     {
 361       const char *checksum;
 362       replay_info_t *info;
 363       svn_txdelta_window_handler_t textdelta;
 364       void *textdelta_baton;
 365       svn_stream_t *delta_stream;
 366
 367       info = push_state(parser, ctx, APPLY_TEXTDELTA);
 368
 369       checksum = svn_xml_get_attr_value("checksum", attrs);
 370       if (checksum)
 371         {
 372           checksum = apr_pstrdup(info->pool, checksum);
 373         }
 374
 375       SVN_ERR(ctx->editor->apply_textdelta(info->baton, checksum,
 376                                            info->pool,
 377                                            &textdelta,
 378                                            &textdelta_baton));
 379
 380       delta_stream = svn_txdelta_parse_svndiff(textdelta, textdelta_baton,
 381                                                TRUE, info->pool);
 382       info->stream = svn_base64_decode(delta_stream, info->pool);
 383     }
 384   else if ((state == OPEN_FILE || state == ADD_FILE) &&
 385            strcmp(name.name, "close-file") == 0)
 386     {
 387       replay_info_t *info = parser->state->private;
 388       const char *checksum;
 389
 390       checksum = svn_xml_get_attr_value("checksum", attrs);
 391
 392       SVN_ERR(ctx->editor->close_file(info->baton, checksum,
 393                                       parser->state->pool));
 394
 395       svn_ra_serf__xml_pop_state(parser);
 396     }
 397   else if (((state == OPEN_FILE || state == ADD_FILE) &&
 398             strcmp(name.name, "change-file-prop") == 0) ||
 399            ((state == OPEN_DIR || state == ADD_DIR) &&
 400             strcmp(name.name, "change-dir-prop") == 0))
 401     {
 402       const char *prop_name;
 403       prop_info_t *info;
 404
 405       prop_name = svn_xml_get_attr_value("name", attrs);
 406       if (!prop_name)
 407         {
 408           return svn_error_createf(SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,
 409                                    _("Missing name attr in %s element"),
 410                                    name.name);
 411         }
 412
 413       info = push_state(parser, ctx, CHANGE_PROP);
 414
 415       info->name = apr_pstrdup(parser->state->pool, prop_name);
 416
 417       if (svn_xml_get_attr_value("del", attrs))
 418         info->del_prop = TRUE;
 419       else
 420         info->del_prop = FALSE;
 421
 422       if (state == OPEN_FILE || state == ADD_FILE)
 423         info->change = ctx->editor->change_file_prop;
 424       else
 425         info->change = ctx->editor->change_dir_prop;
 426
 427     }
 428
 429   return SVN_NO_ERROR;
 430 }
 431
 432 static svn_error_t *
 433 end_replay(svn_ra_serf__xml_parser_t *parser,
 434            void *userData,
 435            svn_ra_serf__dav_props_t name)
 436 {
 437   replay_context_t *ctx = userData;
 438   replay_state_e state;
 439
 440   UNUSED_CTX(ctx);
 441
 442   state = parser->state->current_state;
 443
 444   if (state == REPORT &&
 445       strcmp(name.name, "editor-report") == 0)
 446     {
 447       svn_ra_serf__xml_pop_state(parser);
 448       SVN_ERR(ctx->revfinish_func(ctx->revision, ctx->replay_baton,
 449                                   ctx->editor, ctx->editor_baton,
 450                                   ctx->props,
 451                                   ctx->pool));
 452     }
 453   else if (state == OPEN_DIR && strcmp(name.name, "open-directory") == 0)
 454     {
 455       /* Don't do anything. */
 456     }
 457   else if (state == ADD_DIR && strcmp(name.name, "add-directory") == 0)
 458     {
 459       /* Don't do anything. */
 460     }
 461   else if (state == OPEN_FILE && strcmp(name.name, "open-file") == 0)
 462     {
 463       /* Don't do anything. */
 464     }
 465   else if (state == ADD_FILE && strcmp(name.name, "add-file") == 0)
 466     {
 467       /* Don't do anything. */
 468     }
 469   else if ((state == OPEN_FILE || state == ADD_FILE) &&
 470            strcmp(name.name, "close-file") == 0)
 471     {
 472       /* Don't do anything. */
 473     }
 474   else if ((state == APPLY_TEXTDELTA) &&
 475            strcmp(name.name, "apply-textdelta") == 0)
 476     {
 477       replay_info_t *info = parser->state->private;
 478       SVN_ERR(svn_stream_close(info->stream));
 479       svn_ra_serf__xml_pop_state(parser);
 480     }
 481   else if (state == CHANGE_PROP &&
 482            (strcmp(name.name, "change-file-prop") == 0 ||
 483             strcmp(name.name, "change-dir-prop") == 0))
 484     {
 485       prop_info_t *info = parser->state->private;
 486       const svn_string_t *prop_val;
 487
 488       if (info->del_prop == TRUE)
 489         {
 490           prop_val = NULL;
 491         }
 492       else
 493         {
 494           svn_string_t tmp_prop;
 495
 496           tmp_prop.data = info->data;
 497           tmp_prop.len = info->len;
 498
 499           prop_val = svn_base64_decode_string(&tmp_prop, parser->state->pool);
 500         }
 501
 502       SVN_ERR(info->change(info->parent->baton, info->name, prop_val,
 503                            info->parent->pool));
 504       svn_ra_serf__xml_pop_state(parser);
 505     }
 506
 507   return SVN_NO_ERROR;
 508 }
 509
 510 static svn_error_t *
 511 cdata_replay(svn_ra_serf__xml_parser_t *parser,
 512              void *userData,
 513              const char *data,
 514              apr_size_t len)
 515 {
 516   replay_context_t *replay_ctx = userData;
 517   replay_state_e state;
 518
 519   UNUSED_CTX(replay_ctx);
 520
 521   state = parser->state->current_state;
 522
 523   if (state == APPLY_TEXTDELTA)
 524     {
 525       replay_info_t *info = parser->state->private;
 526       apr_size_t written;
 527
 528       written = len;
 529
 530       SVN_ERR(svn_stream_write(info->stream, data, &written));
 531
 532       if (written != len)
 533         return svn_error_create(SVN_ERR_STREAM_UNEXPECTED_EOF, NULL,
 534                                 _("Error writing stream: unexpected EOF"));
 535     }
 536   else if (state == CHANGE_PROP)
 537     {
 538       prop_info_t *info = parser->state->private;
 539
 540       svn_ra_serf__expand_string(&info->data, &info->len,
 541                                  data, len, parser->state->pool);
 542     }
 543
 544   return SVN_NO_ERROR;
 545 }
 546
 547 static serf_bucket_t *
 548 create_replay_body(void *baton,
 549                    serf_bucket_alloc_t *alloc,
 550                    apr_pool_t *pool)
 551 {
 552   replay_context_t *ctx = baton;
 553   serf_bucket_t *body_bkt, *tmp;
 554
 555   body_bkt = serf_bucket_aggregate_create(alloc);
 556
 557   tmp = SERF_BUCKET_SIMPLE_STRING_LEN("<S:replay-report xmlns:S=\"",
 558                                       sizeof("<S:replay-report xmlns:S=\"")-1,
 559                                       alloc);
 560   serf_bucket_aggregate_append(body_bkt, tmp);
 561
 562   tmp = SERF_BUCKET_SIMPLE_STRING_LEN(SVN_XML_NAMESPACE,
 563                                       sizeof(SVN_XML_NAMESPACE)-1,
 564                                       alloc);
 565   serf_bucket_aggregate_append(body_bkt, tmp);
 566
 567   tmp = SERF_BUCKET_SIMPLE_STRING_LEN("\">",
 568                                       sizeof("\">")-1,
 569                                       alloc);
 570   serf_bucket_aggregate_append(body_bkt, tmp);
 571
 572   svn_ra_serf__add_tag_buckets(body_bkt,
 573                                "S:revision", apr_ltoa(ctx->pool, ctx->revision),
 574                                alloc);
 575   svn_ra_serf__add_tag_buckets(body_bkt,
 576                                "S:low-water-mark",
 577                                apr_ltoa(ctx->pool, ctx->low_water_mark),
 578                                alloc);
 579
 580   svn_ra_serf__add_tag_buckets(body_bkt,
 581                                "S:send-deltas",
 582                                apr_ltoa(ctx->pool, ctx->send_deltas),
 583                                alloc);
 584
 585   tmp = SERF_BUCKET_SIMPLE_STRING_LEN("</S:replay-report>",
 586                                       sizeof("</S:replay-report>")-1,
 587                                       alloc);
 588   serf_bucket_aggregate_append(body_bkt, tmp);
 589
 590   return body_bkt;
 591 }
 592
 593 svn_error_t *
 594 svn_ra_serf__replay(svn_ra_session_t *ra_session,
 595                     svn_revnum_t revision,
 596                     svn_revnum_t low_water_mark,
 597                     svn_boolean_t send_deltas,
 598                     const svn_delta_editor_t *editor,
 599                     void *edit_baton,
 600                     apr_pool_t *pool)
 601 {
 602   replay_context_t *replay_ctx;
 603   svn_ra_serf__session_t *session = ra_session->priv;
 604   svn_ra_serf__handler_t *handler;
 605   svn_ra_serf__xml_parser_t *parser_ctx;
 606
 607   replay_ctx = apr_pcalloc(pool, sizeof(*replay_ctx));
 608   replay_ctx->pool = pool;
 609   replay_ctx->editor = editor;
 610   replay_ctx->editor_baton = edit_baton;
 611   replay_ctx->done = FALSE;
 612   replay_ctx->low_water_mark = low_water_mark;
 613   replay_ctx->send_deltas = send_deltas;
 614
 615   handler = apr_pcalloc(pool, sizeof(*handler));
 616
 617   handler->method = "REPORT";
 618   handler->path = session->repos_url_str;
 619   handler->body_delegate = create_replay_body;
 620   handler->body_delegate_baton = replay_ctx;
 621   handler->body_type = "text/xml";
 622   handler->conn = session->conns[0];
 623   handler->session = session;
 624
 625   parser_ctx = apr_pcalloc(pool, sizeof(*parser_ctx));
 626
 627   parser_ctx->pool = pool;
 628   parser_ctx->user_data = replay_ctx;
 629   parser_ctx->start = start_replay;
 630   parser_ctx->end = end_replay;
 631   parser_ctx->cdata = cdata_replay;
 632   parser_ctx->done = &replay_ctx->done;
 633
 634   handler->response_handler = svn_ra_serf__handle_xml_parser;
 635   handler->response_baton = parser_ctx;
 636
 637   svn_ra_serf__request_create(handler);
 638
 639   return SVN_NO_ERROR;
 640 }
 641
 642 /* The maximum number of outstanding requests at any time. When this number is
 643  * reached, ra_serf will stop sending requests until responses on the previous
 644  * requests are received and handled.
 645  *
 646  * Some observations about serf which lead us to the current value.
 647  * ----------------------------------------------------------------
 648  * We aim to keep serf's outgoing queue filled with enough requests so the
 649  * network bandwidth and server capacity is used optimally. Originally we used
 650  * 5 as the max. number of outstanding requests, but this turned out to be too
 651  * low.
 652  * Serf doesn't exit out of the serf_context_run loop as long as it has
 653  * data to send or receive. With small responses (revs of a few kB), serf
 654  * doesn't come out of this loop at all. So with MAX_OUTSTANDING_REQUESTS set
 655  * to a low number, there's a big chance that serf handles those requests
 656  * completely in its internal loop, and only then gives us a chance to create
 657  * new requests. This results in hiccups, slowing down the whole process.
 658  *
 659  * With a larger MAX_OUTSTANDING_REQUESTS, like 100 or more, there's more chance
 660  * that serf can come out of its internal loop so we can replenish the outgoing
 661  * request queue.
 662  * There's no real disadvantage of using a large number here, besides the memory
 663  * used to store the message, parser and handler objects (approx. 250 bytes).
 664  *
 665  * In my test setup peak performance was reached at max. 30-35 requests. So I
 666  * added a small margin and choose 50.
 667  */
 668 #define MAX_OUTSTANDING_REQUESTS 50
 669
 670 svn_error_t *
 671 svn_ra_serf__replay_range(svn_ra_session_t *ra_session,
 672                           svn_revnum_t start_revision,
 673                           svn_revnum_t end_revision,
 674                           svn_revnum_t low_water_mark,
 675                           svn_boolean_t send_deltas,
 676                           svn_ra_replay_revstart_callback_t revstart_func,
 677                           svn_ra_replay_revfinish_callback_t revfinish_func,
 678                           void *replay_baton,
 679                           apr_pool_t *pool)
 680 {
 681   svn_ra_serf__session_t *session = ra_session->priv;
 682   svn_revnum_t rev = start_revision;
 683   const char *vcc_url;
 684   int active_reports = 0;
 685
 686   SVN_ERR(svn_ra_serf__discover_root(&vcc_url, NULL,
 687                                      session, session->conns[0],
 688                                      session->repos_url.path, pool));
 689
 690   while (active_reports || rev <= end_revision)
 691     {
 692       apr_status_t status;
 693       svn_ra_serf__list_t *done_list;
 694       svn_ra_serf__list_t *done_reports = NULL;
 695       replay_context_t *replay_ctx;
 696
 697       /* Send pending requests, if any. Limit the number of outstanding
 698          requests to MAX_OUTSTANDING_REQUESTS. */
 699       if (rev <= end_revision  && active_reports < MAX_OUTSTANDING_REQUESTS)
 700         {
 701           svn_ra_serf__propfind_context_t *prop_ctx = NULL;
 702           svn_ra_serf__handler_t *handler;
 703           svn_ra_serf__xml_parser_t *parser_ctx;
 704           apr_pool_t *ctx_pool = svn_pool_create(pool);
 705
 706           replay_ctx = apr_pcalloc(ctx_pool, sizeof(*replay_ctx));
 707           replay_ctx->pool = ctx_pool;
 708           replay_ctx->revstart_func = revstart_func;
 709           replay_ctx->revfinish_func = revfinish_func;
 710           replay_ctx->replay_baton = replay_baton;
 711           replay_ctx->done = FALSE;
 712           replay_ctx->revision = rev;
 713           replay_ctx->low_water_mark = low_water_mark;
 714           replay_ctx->send_deltas = send_deltas;
 715           replay_ctx->done_item.data = replay_ctx;
 716           /* Request all properties of a certain revision. */
 717           replay_ctx->vcc_url = vcc_url;
 718           replay_ctx->revs_props = apr_hash_make(replay_ctx->pool);
 719           SVN_ERR(svn_ra_serf__deliver_props(&prop_ctx,
 720                                              replay_ctx->revs_props, session,
 721                                              session->conns[0], vcc_url,
 722                                              rev,  "0", all_props,
 723                                              TRUE, NULL, replay_ctx->pool));
 724
 725           /* Send the replay report request. */
 726           handler = apr_pcalloc(replay_ctx->pool, sizeof(*handler));
 727
 728           handler->method = "REPORT";
 729           handler->path = session->repos_url_str;
 730           handler->body_delegate = create_replay_body;
 731           handler->body_delegate_baton = replay_ctx;
 732           handler->conn = session->conns[0];
 733           handler->session = session;
 734
 735           parser_ctx = apr_pcalloc(replay_ctx->pool, sizeof(*parser_ctx));
 736
 737           /* Setup the XML parser context.
 738              Because we have not one but a list of requests, the 'done' property
 739              on the replay_ctx is not of much use. Instead, use 'done_list'.
 740              On each handled response (succesfully or not), the parser will add
 741              done_item to done_list, so by keeping track of the state of
 742              done_list we know how many requests have been handled completely.
 743           */
 744           parser_ctx->pool = replay_ctx->pool;
 745           parser_ctx->user_data = replay_ctx;
 746           parser_ctx->start = start_replay;
 747           parser_ctx->end = end_replay;
 748           parser_ctx->cdata = cdata_replay;
 749           parser_ctx->done = &replay_ctx->done;
 750           parser_ctx->done_list = &done_reports;
 751           parser_ctx->done_item = &replay_ctx->done_item;
 752           handler->response_handler = svn_ra_serf__handle_xml_parser;
 753           handler->response_baton = parser_ctx;
 754
 755           svn_ra_serf__request_create(handler);
 756
 757           rev++;
 758           active_reports++;
 759         }
 760
 761       /* Run the serf loop, send outgoing and process incoming requests.
 762          This request will block when there are no more requests to send or
 763          responses to receive, so we have to be careful on our bookkeeping. */
 764       status = serf_context_run(session->context, SERF_DURATION_FOREVER,
 765                                 pool);
 766       if (status)
 767         {
 768           SVN_ERR(session->pending_error);
 769
 770           return svn_error_wrap_apr(status,
 771                                     _("Error retrieving replay REPORT (%d)"),
 772                                     status);
 773         }
 774
 775       /* Substract the number of completely handled responses from our
 776          total nr. of open requests', so we'll know when to stop this loop.
 777          Since the message is completely handled, we can destroy its pool. */
 778       done_list = done_reports;
 779       while (done_list)
 780         {
 781           replay_context_t *ctx = (replay_context_t *)done_list->data;
 782           done_list = done_list->next;
 783           svn_pool_destroy(ctx->pool);
 784           active_reports--;
 785         }
 786       done_reports = NULL;
 787     }
 788
 789   return SVN_NO_ERROR;
 790 }
 791 #undef MAX_OUTSTANDING_REQUESTS