src/push.c

   1 /*
   2  * Copyright (C) the libgit2 contributors. All rights reserved.
   3  *
   4  * This file is part of libgit2, distributed under the GNU GPL v2 with
   5  * a Linking Exception. For full terms see the included COPYING file.
   6  */
   7
   8 #include "push.h"
   9
  10 #include "git2.h"
  11
  12 #include "pack.h"
  13 #include "pack-objects.h"
  14 #include "remote.h"
  15 #include "vector.h"
  16 #include "tree.h"
  17
  18 static int push_spec_rref_cmp(const void *a, const void *b)
  19 {
  20         const push_spec *push_spec_a = a, *push_spec_b = b;
  21
  22         return strcmp(push_spec_a->refspec.dst, push_spec_b->refspec.dst);
  23 }
  24
  25 static int push_status_ref_cmp(const void *a, const void *b)
  26 {
  27         const push_status *push_status_a = a, *push_status_b = b;
  28
  29         return strcmp(push_status_a->ref, push_status_b->ref);
  30 }
  31
  32 int git_push_new(git_push **out, git_remote *remote, const git_push_options *opts)
  33 {
  34         git_push *p;
  35
  36         *out = NULL;
  37
  38         GIT_ERROR_CHECK_VERSION(opts, GIT_PUSH_OPTIONS_VERSION, "git_push_options");
  39
  40         p = git__calloc(1, sizeof(*p));
  41         GIT_ERROR_CHECK_ALLOC(p);
  42
  43         p->repo = remote->repo;
  44         p->remote = remote;
  45         p->report_status = 1;
  46         p->pb_parallelism = opts ? opts->pb_parallelism : 1;
  47
  48         if (opts) {
  49                 GIT_ERROR_CHECK_VERSION(&opts->callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
  50                 memcpy(&p->callbacks, &opts->callbacks, sizeof(git_remote_callbacks));
  51         }
  52
  53         if (git_vector_init(&p->specs, 0, push_spec_rref_cmp) < 0) {
  54                 git__free(p);
  55                 return -1;
  56         }
  57
  58         if (git_vector_init(&p->status, 0, push_status_ref_cmp) < 0) {
  59                 git_vector_free(&p->specs);
  60                 git__free(p);
  61                 return -1;
  62         }
  63
  64         if (git_vector_init(&p->updates, 0, NULL) < 0) {
  65                 git_vector_free(&p->status);
  66                 git_vector_free(&p->specs);
  67                 git__free(p);
  68                 return -1;
  69         }
  70
  71         *out = p;
  72         return 0;
  73 }
  74
  75 static void free_refspec(push_spec *spec)
  76 {
  77         if (spec == NULL)
  78                 return;
  79
  80         git_refspec__dispose(&spec->refspec);
  81         git__free(spec);
  82 }
  83
  84 static int check_rref(char *ref)
  85 {
  86         if (git__prefixcmp(ref, "refs/")) {
  87                 git_error_set(GIT_ERROR_INVALID, "not a valid reference '%s'", ref);
  88                 return -1;
  89         }
  90
  91         return 0;
  92 }
  93
  94 static int check_lref(git_push *push, char *ref)
  95 {
  96         /* lref must be resolvable to an existing object */
  97         git_object *obj;
  98         int error = git_revparse_single(&obj, push->repo, ref);
  99         git_object_free(obj);
 100
 101         if (!error)
 102                 return 0;
 103
 104         if (error == GIT_ENOTFOUND)
 105                 git_error_set(GIT_ERROR_REFERENCE,
 106                         "src refspec '%s' does not match any existing object", ref);
 107         else
 108                 git_error_set(GIT_ERROR_INVALID, "not a valid reference '%s'", ref);
 109         return -1;
 110 }
 111
 112 static int parse_refspec(git_push *push, push_spec **spec, const char *str)
 113 {
 114         push_spec *s;
 115
 116         *spec = NULL;
 117
 118         s = git__calloc(1, sizeof(*s));
 119         GIT_ERROR_CHECK_ALLOC(s);
 120
 121         if (git_refspec__parse(&s->refspec, str, false) < 0) {
 122                 git_error_set(GIT_ERROR_INVALID, "invalid refspec %s", str);
 123                 goto on_error;
 124         }
 125
 126         if (s->refspec.src && s->refspec.src[0] != '\0' &&
 127             check_lref(push, s->refspec.src) < 0) {
 128                 goto on_error;
 129         }
 130
 131         if (check_rref(s->refspec.dst) < 0)
 132                 goto on_error;
 133
 134         *spec = s;
 135         return 0;
 136
 137 on_error:
 138         free_refspec(s);
 139         return -1;
 140 }
 141
 142 int git_push_add_refspec(git_push *push, const char *refspec)
 143 {
 144         push_spec *spec;
 145
 146         if (parse_refspec(push, &spec, refspec) < 0 ||
 147             git_vector_insert(&push->specs, spec) < 0)
 148                 return -1;
 149
 150         return 0;
 151 }
 152
 153 int git_push_update_tips(git_push *push, const git_remote_callbacks *callbacks)
 154 {
 155         git_str remote_ref_name = GIT_STR_INIT;
 156         size_t i, j;
 157         git_refspec *fetch_spec;
 158         push_spec *push_spec = NULL;
 159         git_reference *remote_ref;
 160         push_status *status;
 161         int error = 0;
 162
 163         git_vector_foreach(&push->status, i, status) {
 164                 int fire_callback = 1;
 165
 166                 /* Skip unsuccessful updates which have non-empty messages */
 167                 if (status->msg)
 168                         continue;
 169
 170                 /* Find the corresponding remote ref */
 171                 fetch_spec = git_remote__matching_refspec(push->remote, status->ref);
 172                 if (!fetch_spec)
 173                         continue;
 174
 175                 /* Clear the buffer which can be dirty from previous iteration */
 176                 git_str_clear(&remote_ref_name);
 177
 178                 if ((error = git_refspec__transform(&remote_ref_name, fetch_spec, status->ref)) < 0)
 179                         goto on_error;
 180
 181                 /* Find matching  push ref spec */
 182                 git_vector_foreach(&push->specs, j, push_spec) {
 183                         if (!strcmp(push_spec->refspec.dst, status->ref))
 184                                 break;
 185                 }
 186
 187                 /* Could not find the corresponding push ref spec for this push update */
 188                 if (j == push->specs.length)
 189                         continue;
 190
 191                 /* Update the remote ref */
 192                 if (git_oid_is_zero(&push_spec->loid)) {
 193                         error = git_reference_lookup(&remote_ref, push->remote->repo, git_str_cstr(&remote_ref_name));
 194
 195                         if (error >= 0) {
 196                                 error = git_reference_delete(remote_ref);
 197                                 git_reference_free(remote_ref);
 198                         }
 199                 } else {
 200                         error = git_reference_create(NULL, push->remote->repo,
 201                                                 git_str_cstr(&remote_ref_name), &push_spec->loid, 1,
 202                                                 "update by push");
 203                 }
 204
 205                 if (error < 0) {
 206                         if (error != GIT_ENOTFOUND)
 207                                 goto on_error;
 208
 209                         git_error_clear();
 210                         fire_callback = 0;
 211                 }
 212
 213                 if (fire_callback && callbacks && callbacks->update_tips) {
 214                         error = callbacks->update_tips(git_str_cstr(&remote_ref_name),
 215                                                 &push_spec->roid, &push_spec->loid, callbacks->payload);
 216
 217                         if (error < 0)
 218                                 goto on_error;
 219                 }
 220         }
 221
 222         error = 0;
 223
 224 on_error:
 225         git_str_dispose(&remote_ref_name);
 226         return error;
 227 }
 228
 229 /**
 230  * Insert all tags until we find a non-tag object, which is returned
 231  * in `out`.
 232  */
 233 static int enqueue_tag(git_object **out, git_push *push, git_oid *id)
 234 {
 235         git_object *obj = NULL, *target = NULL;
 236         int error;
 237
 238         if ((error = git_object_lookup(&obj, push->repo, id, GIT_OBJECT_TAG)) < 0)
 239                 return error;
 240
 241         while (git_object_type(obj) == GIT_OBJECT_TAG) {
 242                 if ((error = git_packbuilder_insert(push->pb, git_object_id(obj), NULL)) < 0)
 243                         break;
 244
 245                 if ((error = git_tag_target(&target, (git_tag *) obj)) < 0)
 246                         break;
 247
 248                 git_object_free(obj);
 249                 obj = target;
 250         }
 251
 252         if (error < 0)
 253                 git_object_free(obj);
 254         else
 255                 *out = obj;
 256
 257         return error;
 258 }
 259
 260 static int queue_objects(git_push *push)
 261 {
 262         git_remote_head *head;
 263         push_spec *spec;
 264         git_revwalk *rw;
 265         unsigned int i;
 266         int error = -1;
 267
 268         if (git_revwalk_new(&rw, push->repo) < 0)
 269                 return -1;
 270
 271         git_revwalk_sorting(rw, GIT_SORT_TIME);
 272
 273         git_vector_foreach(&push->specs, i, spec) {
 274                 git_object_t type;
 275                 size_t size;
 276
 277                 if (git_oid_is_zero(&spec->loid))
 278                         /*
 279                          * Delete reference on remote side;
 280                          * nothing to do here.
 281                          */
 282                         continue;
 283
 284                 if (git_oid_equal(&spec->loid, &spec->roid))
 285                         continue; /* up-to-date */
 286
 287                 if ((error = git_odb_read_header(&size, &type, push->repo->_odb, &spec->loid)) < 0)
 288                         goto on_error;
 289
 290                 if (type == GIT_OBJECT_TAG) {
 291                         git_object *target;
 292
 293                         if ((error = enqueue_tag(&target, push, &spec->loid)) < 0)
 294                                 goto on_error;
 295
 296                         if (git_object_type(target) == GIT_OBJECT_COMMIT) {
 297                                 if ((error = git_revwalk_push(rw, git_object_id(target))) < 0) {
 298                                         git_object_free(target);
 299                                         goto on_error;
 300                                 }
 301                         } else {
 302                                 if ((error = git_packbuilder_insert(
 303                                         push->pb, git_object_id(target), NULL)) < 0) {
 304                                         git_object_free(target);
 305                                         goto on_error;
 306                                 }
 307                         }
 308                         git_object_free(target);
 309                 } else if ((error = git_revwalk_push(rw, &spec->loid)) < 0)
 310                         goto on_error;
 311
 312                 if (!spec->refspec.force) {
 313                         git_oid base;
 314
 315                         if (git_oid_is_zero(&spec->roid))
 316                                 continue;
 317
 318                         if (!git_odb_exists(push->repo->_odb, &spec->roid)) {
 319                                 git_error_set(GIT_ERROR_REFERENCE,
 320                                         "cannot push because a reference that you are trying to update on the remote contains commits that are not present locally.");
 321                                 error = GIT_ENONFASTFORWARD;
 322                                 goto on_error;
 323                         }
 324
 325                         error = git_merge_base(&base, push->repo,
 326                                                &spec->loid, &spec->roid);
 327
 328                         if (error == GIT_ENOTFOUND ||
 329                                 (!error && !git_oid_equal(&base, &spec->roid))) {
 330                                 git_error_set(GIT_ERROR_REFERENCE,
 331                                         "cannot push non-fastforwardable reference");
 332                                 error = GIT_ENONFASTFORWARD;
 333                                 goto on_error;
 334                         }
 335
 336                         if (error < 0)
 337                                 goto on_error;
 338                 }
 339         }
 340
 341         git_vector_foreach(&push->remote->refs, i, head) {
 342                 if (git_oid_is_zero(&head->oid))
 343                         continue;
 344
 345                 if ((error = git_revwalk_hide(rw, &head->oid)) < 0 &&
 346                     error != GIT_ENOTFOUND && error != GIT_EINVALIDSPEC && error != GIT_EPEEL)
 347                         goto on_error;
 348         }
 349
 350         error = git_packbuilder_insert_walk(push->pb, rw);
 351
 352 on_error:
 353         git_revwalk_free(rw);
 354         return error;
 355 }
 356
 357 static int add_update(git_push *push, push_spec *spec)
 358 {
 359         git_push_update *u = git__calloc(1, sizeof(git_push_update));
 360         GIT_ERROR_CHECK_ALLOC(u);
 361
 362         u->src_refname = git__strdup(spec->refspec.src);
 363         GIT_ERROR_CHECK_ALLOC(u->src_refname);
 364
 365         u->dst_refname = git__strdup(spec->refspec.dst);
 366         GIT_ERROR_CHECK_ALLOC(u->dst_refname);
 367
 368         git_oid_cpy(&u->src, &spec->roid);
 369         git_oid_cpy(&u->dst, &spec->loid);
 370
 371         return git_vector_insert(&push->updates, u);
 372 }
 373
 374 static int calculate_work(git_push *push)
 375 {
 376         git_remote_head *head;
 377         push_spec *spec;
 378         unsigned int i, j;
 379
 380         /* Update local and remote oids*/
 381
 382         git_vector_foreach(&push->specs, i, spec) {
 383                 if (spec->refspec.src && spec->refspec.src[0]!= '\0') {
 384                         /* This is a create or update.  Local ref must exist. */
 385                         if (git_reference_name_to_id(
 386                                         &spec->loid, push->repo, spec->refspec.src) < 0) {
 387                                 git_error_set(GIT_ERROR_REFERENCE, "no such reference '%s'", spec->refspec.src);
 388                                 return -1;
 389                         }
 390                 }
 391
 392                 /* Remote ref may or may not (e.g. during create) already exist. */
 393                 git_vector_foreach(&push->remote->refs, j, head) {
 394                         if (!strcmp(spec->refspec.dst, head->name)) {
 395                                 git_oid_cpy(&spec->roid, &head->oid);
 396                                 break;
 397                         }
 398                 }
 399
 400                 if (add_update(push, spec) < 0)
 401                         return -1;
 402         }
 403
 404         return 0;
 405 }
 406
 407 static int do_push(git_push *push)
 408 {
 409         int error = 0;
 410         git_transport *transport = push->remote->transport;
 411         git_remote_callbacks *callbacks = &push->callbacks;
 412
 413         if (!transport->push) {
 414                 git_error_set(GIT_ERROR_NET, "remote transport doesn't support push");
 415                 error = -1;
 416                 goto on_error;
 417         }
 418
 419         /*
 420          * A pack-file MUST be sent if either create or update command
 421          * is used, even if the server already has all the necessary
 422          * objects.  In this case the client MUST send an empty pack-file.
 423          */
 424
 425         if ((error = git_packbuilder_new(&push->pb, push->repo)) < 0)
 426                 goto on_error;
 427
 428         git_packbuilder_set_threads(push->pb, push->pb_parallelism);
 429
 430         if (callbacks && callbacks->pack_progress)
 431                 if ((error = git_packbuilder_set_callbacks(push->pb, callbacks->pack_progress, callbacks->payload)) < 0)
 432                         goto on_error;
 433
 434         if ((error = calculate_work(push)) < 0)
 435                 goto on_error;
 436
 437         if (callbacks && callbacks->push_negotiation &&
 438             (error = callbacks->push_negotiation((const git_push_update **) push->updates.contents,
 439                                           push->updates.length, callbacks->payload)) < 0)
 440             goto on_error;
 441
 442         if ((error = queue_objects(push)) < 0 ||
 443             (error = transport->push(transport, push)) < 0)
 444                 goto on_error;
 445
 446 on_error:
 447         git_packbuilder_free(push->pb);
 448         return error;
 449 }
 450
 451 static int filter_refs(git_remote *remote)
 452 {
 453         const git_remote_head **heads;
 454         size_t heads_len, i;
 455
 456         git_vector_clear(&remote->refs);
 457
 458         if (git_remote_ls(&heads, &heads_len, remote) < 0)
 459                 return -1;
 460
 461         for (i = 0; i < heads_len; i++) {
 462                 if (git_vector_insert(&remote->refs, (void *)heads[i]) < 0)
 463                         return -1;
 464         }
 465
 466         return 0;
 467 }
 468
 469 int git_push_finish(git_push *push)
 470 {
 471         int error;
 472
 473         if (!git_remote_connected(push->remote)) {
 474                 git_error_set(GIT_ERROR_NET, "remote is disconnected");
 475                 return -1;
 476         }
 477
 478         if ((error = filter_refs(push->remote)) < 0 ||
 479             (error = do_push(push)) < 0)
 480                 return error;
 481
 482         if (!push->unpack_ok) {
 483                 error = -1;
 484                 git_error_set(GIT_ERROR_NET, "unpacking the sent packfile failed on the remote");
 485         }
 486
 487         return error;
 488 }
 489
 490 int git_push_status_foreach(git_push *push,
 491                 int (*cb)(const char *ref, const char *msg, void *data),
 492                 void *data)
 493 {
 494         push_status *status;
 495         unsigned int i;
 496
 497         git_vector_foreach(&push->status, i, status) {
 498                 int error = cb(status->ref, status->msg, data);
 499                 if (error)
 500                         return git_error_set_after_callback(error);
 501         }
 502
 503         return 0;
 504 }
 505
 506 void git_push_status_free(push_status *status)
 507 {
 508         if (status == NULL)
 509                 return;
 510
 511         git__free(status->msg);
 512         git__free(status->ref);
 513         git__free(status);
 514 }
 515
 516 void git_push_free(git_push *push)
 517 {
 518         push_spec *spec;
 519         push_status *status;
 520         git_push_update *update;
 521         unsigned int i;
 522
 523         if (push == NULL)
 524                 return;
 525
 526         git_vector_foreach(&push->specs, i, spec) {
 527                 free_refspec(spec);
 528         }
 529         git_vector_free(&push->specs);
 530
 531         git_vector_foreach(&push->status, i, status) {
 532                 git_push_status_free(status);
 533         }
 534         git_vector_free(&push->status);
 535
 536         git_vector_foreach(&push->updates, i, update) {
 537                 git__free(update->src_refname);
 538                 git__free(update->dst_refname);
 539                 git__free(update);
 540         }
 541         git_vector_free(&push->updates);
 542
 543         git__free(push);
 544 }
 545
 546 int git_push_options_init(git_push_options *opts, unsigned int version)
 547 {
 548         GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 549                 opts, version, git_push_options, GIT_PUSH_OPTIONS_INIT);
 550         return 0;
 551 }
 552
 553 #ifndef GIT_DEPRECATE_HARD
 554 int git_push_init_options(git_push_options *opts, unsigned int version)
 555 {
 556         return git_push_options_init(opts, version);
 557 }
 558 #endif