Hello community, here is the log from the commit of package libgit2 for openSUSE:Factory checked in at 2020-06-23 20:59:54 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/libgit2 (Old) and /work/SRC/openSUSE:Factory/.libgit2.new.2956 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "libgit2" Tue Jun 23 20:59:54 2020 rev:41 rq:816328 version:1.0.1 Changes: -------- --- /work/SRC/openSUSE:Factory/libgit2/libgit2.changes 2020-04-27 23:28:17.662342256 +0200 +++ /work/SRC/openSUSE:Factory/.libgit2.new.2956/libgit2.changes 2020-06-23 21:00:10.636982865 +0200 @@ -1,0 +2,12 @@ +Sat Jun 20 17:49:44 UTC 2020 - Andreas Stieger <[email protected]> + +- update to 1.0.1: + * Improve merge efficiency + * git_worktree_prune_init_options restored for backward + compatibility + * Configuration files that are unreadable due to permissions are + now silently ignored, and treated as if they do not exist + * v4 index files are now correctly written + * Improve compatibility with some servers including Gerrit + +------------------------------------------------------------------- Old: ---- libgit2-1.0.0.tar.gz New: ---- libgit2-1.0.1.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ libgit2.spec ++++++ --- /var/tmp/diff_new_pack.XG1HYP/_old 2020-06-23 21:00:11.440985577 +0200 +++ /var/tmp/diff_new_pack.XG1HYP/_new 2020-06-23 21:00:11.444985591 +0200 @@ -18,9 +18,8 @@ %define sover 1_0 - Name: libgit2 -Version: 1.0.0 +Version: 1.0.1 Release: 0 Summary: C git library License: GPL-2.0 WITH GCC-exception-2.0 @@ -28,7 +27,6 @@ URL: https://libgit2.github.com/ Source0: https://github.com/libgit2/libgit2/archive/v%{version}.tar.gz#/%{name}-%{version}.tar.gz Source99: baselibs.conf - BuildRequires: cmake >= 2.8 BuildRequires: http-parser-devel BuildRequires: pkgconfig ++++++ libgit2-1.0.0.tar.gz -> libgit2-1.0.1.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libgit2-1.0.0/deps/ntlmclient/compat.h new/libgit2-1.0.1/deps/ntlmclient/compat.h --- old/libgit2-1.0.0/deps/ntlmclient/compat.h 2020-04-01 15:49:12.000000000 +0200 +++ new/libgit2-1.0.1/deps/ntlmclient/compat.h 2020-06-04 10:46:58.000000000 +0200 @@ -25,7 +25,7 @@ /* See man page endian(3) */ # include <endian.h> # define htonll htobe64 -#elif defined(__OpenBSD__) +#elif defined(__NetBSD__) || defined(__OpenBSD__) /* See man page htobe64(3) */ # include <endian.h> # define htonll htobe64 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libgit2-1.0.0/docs/changelog.md new/libgit2-1.0.1/docs/changelog.md --- old/libgit2-1.0.0/docs/changelog.md 2020-04-01 15:49:12.000000000 +0200 +++ new/libgit2-1.0.1/docs/changelog.md 2020-06-04 10:46:58.000000000 +0200 @@ -1,3 +1,33 @@ +v1.0.1 +------ + +This is a bugfix release with the following changes: + +- Calculating information about renamed files during merges is more + efficient because dissimilarity about files is now being cached and + no longer needs to be recomputed. + +- The `git_worktree_prune_init_options` has been correctly restored for + backward compatibility. In v1.0 it was incorrectly deprecated with a + typo. + +- The optional ntlmclient dependency now supports NetBSD. + +- A bug where attempting to stash on a bare repository may have failed + has been fixed. + +- Configuration files that are unreadable due to permissions are now + silently ignored, and treated as if they do not exist. This matches + git's behavior; previously this case would have been an error. + +- v4 index files are now correctly written; previously we would read + them correctly but would not write the prefix-compression accurately, + causing corruption. + +- A bug where the smart HTTP transport could not read large data packets + has been fixed. Previously, fetching from servers like Gerrit, that + sent large data packets, would error. + v1.0 ---- diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libgit2-1.0.0/include/git2/version.h new/libgit2-1.0.1/include/git2/version.h --- old/libgit2-1.0.0/include/git2/version.h 2020-04-01 15:49:12.000000000 +0200 +++ new/libgit2-1.0.1/include/git2/version.h 2020-06-04 10:46:58.000000000 +0200 @@ -7,10 +7,10 @@ #ifndef INCLUDE_git_version_h__ #define INCLUDE_git_version_h__ -#define LIBGIT2_VERSION "1.0.0" +#define LIBGIT2_VERSION "1.0.1" #define LIBGIT2_VER_MAJOR 1 #define LIBGIT2_VER_MINOR 0 -#define LIBGIT2_VER_REVISION 0 +#define LIBGIT2_VER_REVISION 1 #define LIBGIT2_VER_PATCH 0 #define LIBGIT2_SOVERSION "1.0" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libgit2-1.0.0/package.json new/libgit2-1.0.1/package.json --- old/libgit2-1.0.0/package.json 2020-04-01 15:49:12.000000000 +0200 +++ new/libgit2-1.0.1/package.json 2020-06-04 10:46:58.000000000 +0200 @@ -1,6 +1,6 @@ { "name": "libgit2", - "version": "0.27.0", + "version": "1.0.1", "repo": "https://github.com/libgit2/libgit2";, "description": " A cross-platform, linkable library implementation of Git that you can use in your application.", "install": "mkdir build && cd build && cmake .. && cmake --build ." diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libgit2-1.0.0/script/release.py new/libgit2-1.0.1/script/release.py --- old/libgit2-1.0.0/script/release.py 2020-04-01 15:49:12.000000000 +0200 +++ new/libgit2-1.0.1/script/release.py 2020-06-04 10:46:58.000000000 +0200 @@ -56,6 +56,17 @@ if v[0] != v[1]: raise Error("version.h: define '{}' does not match (got '{}', expected '{}')".format(k, v[0], v[1])) + with open('package.json') as f: + pkg = json.load(f) + + try: + pkg_version = Version(pkg["version"]) + except KeyError as err: + raise Error("package.json: missing the field {}".format(err)) + + if pkg_version != version: + raise Error("package.json: version does not match (got '{}', expected '{}')".format(pkg_version, version)) + def generate_relnotes(tree, version): with open('docs/changelog.md') as f: lines = f.readlines() diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libgit2-1.0.0/src/config_file.c new/libgit2-1.0.1/src/config_file.c --- old/libgit2-1.0.0/src/config_file.c 2020-04-01 15:49:12.000000000 +0200 +++ new/libgit2-1.0.1/src/config_file.c 2020-06-04 10:46:58.000000000 +0200 @@ -111,6 +111,15 @@ if (!git_path_exists(b->file.path)) return 0; + /* + * git silently ignores configuration files that are not + * readable. We emulate that behavior. This is particularly + * important for sandboxed applications on macOS where the + * git configuration files may not be readable. + */ + if (p_access(b->file.path, R_OK) < 0) + return GIT_ENOTFOUND; + if (res < 0 || (res = config_file_read(b->entries, repo, &b->file, level, 0)) < 0) { git_config_entries_free(b->entries); b->entries = NULL; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libgit2-1.0.0/src/index.c new/libgit2-1.0.1/src/index.c --- old/libgit2-1.0.0/src/index.c 2020-04-01 15:49:12.000000000 +0200 +++ new/libgit2-1.0.1/src/index.c 2020-06-04 10:46:58.000000000 +0200 @@ -2744,7 +2744,7 @@ ++same_len; } path_len -= same_len; - varint_len = git_encode_varint(NULL, 0, same_len); + varint_len = git_encode_varint(NULL, 0, strlen(last) - same_len); } disk_size = index_entry_size(path_len, varint_len, entry->flags); @@ -2795,7 +2795,7 @@ if (last) { varint_len = git_encode_varint((unsigned char *) path, - disk_size, same_len); + disk_size, strlen(last) - same_len); assert(varint_len > 0); path += varint_len; disk_size -= varint_len; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libgit2-1.0.0/src/merge.c new/libgit2-1.0.1/src/merge.c --- old/libgit2-1.0.0/src/merge.c 2020-04-01 15:49:12.000000000 +0200 +++ new/libgit2-1.0.1/src/merge.c 2020-06-04 10:46:58.000000000 +0200 @@ -68,6 +68,16 @@ git_merge_diff *prev_conflict; }; +/* + * This acts as a negative cache entry marker. In case we've tried to calculate + * similarity metrics for a given blob already but `git_hashsig` determined + * that it's too small in order to have a meaningful hash signature, we will + * insert the address of this marker instead of `NULL`. Like this, we can + * easily check whether we have checked a gien entry already and skip doing the + * calculation again and again. + */ +static int cache_invalid_marker; + /* Merge base computation */ int merge_bases_many(git_commit_list **out, git_revwalk **walk_out, git_repository *repo, size_t length, const git_oid input_array[]) @@ -1027,6 +1037,9 @@ git_object_size_t blobsize; int error; + if (*out || *out == &cache_invalid_marker) + return 0; + *out = NULL; if ((error = git_blob_lookup(&blob, repo, &entry->id)) < 0) @@ -1047,6 +1060,8 @@ error = opts->metric->buffer_signature(out, &diff_file, git_blob_rawcontent(blob), (size_t)blobsize, opts->metric->payload); + if (error == GIT_EBUFS) + *out = &cache_invalid_marker; git_blob_free(blob); @@ -1069,18 +1084,16 @@ return 0; /* update signature cache if needed */ - if (!cache[a_idx] && (error = index_entry_similarity_calc(&cache[a_idx], repo, a, opts)) < 0) - return error; - if (!cache[b_idx] && (error = index_entry_similarity_calc(&cache[b_idx], repo, b, opts)) < 0) + if ((error = index_entry_similarity_calc(&cache[a_idx], repo, a, opts)) < 0 || + (error = index_entry_similarity_calc(&cache[b_idx], repo, b, opts)) < 0) return error; /* some metrics may not wish to process this file (too big / too small) */ - if (!cache[a_idx] || !cache[b_idx]) + if (cache[a_idx] == &cache_invalid_marker || cache[b_idx] == &cache_invalid_marker) return 0; /* compare signatures */ - if (opts->metric->similarity( - &score, cache[a_idx], cache[b_idx], opts->metric->payload) < 0) + if (opts->metric->similarity(&score, cache[a_idx], cache[b_idx], opts->metric->payload) < 0) return -1; /* clip score */ @@ -1550,7 +1563,7 @@ done: if (cache != NULL) { for (i = 0; i < cache_size; ++i) { - if (cache[i] != NULL) + if (cache[i] != NULL && cache[i] != &cache_invalid_marker) opts->metric->free_signature(cache[i], opts->metric->payload); } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libgit2-1.0.0/src/stash.c new/libgit2-1.0.1/src/stash.c --- old/libgit2-1.0.0/src/stash.c 2020-04-01 15:49:12.000000000 +0200 +++ new/libgit2-1.0.1/src/stash.c 2020-06-04 10:46:58.000000000 +0200 @@ -173,7 +173,7 @@ git_index *index, const char *path) { - git_index *repo_index; + git_index *repo_index = NULL; git_index_entry entry = {{0}}; struct stat st; int error; @@ -187,7 +187,7 @@ return error; git_index_entry__init_from_stat(&entry, &st, - (repo_index != NULL || !repo_index->distrust_filemode)); + (repo_index == NULL || !repo_index->distrust_filemode)); entry.path = path; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libgit2-1.0.0/src/transports/httpclient.c new/libgit2-1.0.1/src/transports/httpclient.c --- old/libgit2-1.0.0/src/transports/httpclient.c 2020-04-01 15:49:12.000000000 +0200 +++ new/libgit2-1.0.1/src/transports/httpclient.c 2020-06-04 10:46:58.000000000 +0200 @@ -1038,6 +1038,7 @@ GIT_INLINE(int) client_read(git_http_client *client) { + http_parser_context *parser_context = client->parser.data; git_stream *stream; char *buf = client->read_buf.ptr + client->read_buf.size; size_t max_len; @@ -1054,6 +1055,9 @@ max_len = client->read_buf.asize - client->read_buf.size; max_len = min(max_len, INT_MAX); + if (parser_context->output_size) + max_len = min(max_len, parser_context->output_size); + if (max_len == 0) { git_error_set(GIT_ERROR_HTTP, "no room in output buffer"); return -1; @@ -1191,7 +1195,7 @@ /* If we're not keeping alive, don't bother. */ if (!client->keepalive) { client->connected = 0; - return; + goto done; } parser_context.client = client; @@ -1205,6 +1209,9 @@ git_error_clear(); client->connected = 0; } + +done: + git_buf_clear(&client->read_buf); } int git_http_client_send_request( @@ -1419,15 +1426,20 @@ client->parser.data = &parser_context; /* - * Clients expect to get a non-zero amount of data from us. - * With a sufficiently small buffer, one might only read a chunk - * length. Loop until we actually have data to return. + * Clients expect to get a non-zero amount of data from us, + * so we either block until we have data to return, until we + * hit EOF or there's an error. Do this in a loop, since we + * may end up reading only some stream metadata (like chunk + * information). */ while (!parser_context.output_written) { error = client_read_and_parse(client); if (error <= 0) goto done; + + if (client->state == DONE) + break; } assert(parser_context.output_written <= INT_MAX); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libgit2-1.0.0/src/worktree.c new/libgit2-1.0.1/src/worktree.c --- old/libgit2-1.0.0/src/worktree.c 2020-04-01 15:49:12.000000000 +0200 +++ new/libgit2-1.0.1/src/worktree.c 2020-06-04 10:46:58.000000000 +0200 @@ -506,7 +506,7 @@ return 0; } -int git_worktree_pruneinit_options(git_worktree_prune_options *opts, +int git_worktree_prune_init_options(git_worktree_prune_options *opts, unsigned int version) { return git_worktree_prune_options_init(opts, version); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libgit2-1.0.0/tests/config/read.c new/libgit2-1.0.1/tests/config/read.c --- old/libgit2-1.0.0/tests/config/read.c 2020-04-01 15:49:12.000000000 +0200 +++ new/libgit2-1.0.1/tests/config/read.c 2020-06-04 10:46:58.000000000 +0200 @@ -849,6 +849,23 @@ git_config_free(cfg); } +void test_config_read__unreadable_file_ignored(void) +{ + git_buf buf = GIT_BUF_INIT; + git_config *cfg; + int ret; + + cl_set_cleanup(&clean_test_config, NULL); + cl_git_mkfile("./testconfig", "[some] var = value\n[some \"OtheR\"] var = value"); + cl_git_pass(p_chmod("./testconfig", 0)); + + ret = git_config_open_ondisk(&cfg, "./test/config"); + cl_assert(ret == 0 || ret == GIT_ENOTFOUND); + + git_config_free(cfg); + git_buf_dispose(&buf); +} + void test_config_read__single_line(void) { git_buf buf = GIT_BUF_INIT; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libgit2-1.0.0/tests/index/version.c new/libgit2-1.0.1/tests/index/version.c --- old/libgit2-1.0.0/tests/index/version.c 2020-04-01 15:49:12.000000000 +0200 +++ new/libgit2-1.0.1/tests/index/version.c 2020-06-04 10:46:58.000000000 +0200 @@ -43,6 +43,7 @@ "xz", "xyzzyx" }; + git_repository *repo; git_index_entry entry; git_index *index; size_t i; @@ -63,7 +64,8 @@ cl_git_pass(git_index_write(index)); git_index_free(index); - cl_git_pass(git_repository_index(&index, g_repo)); + cl_git_pass(git_repository_open(&repo, git_repository_path(g_repo))); + cl_git_pass(git_repository_index(&index, repo)); cl_assert(git_index_version(index) == 4); for (i = 0; i < ARRAY_SIZE(paths); i++) { @@ -74,6 +76,7 @@ } git_index_free(index); + git_repository_free(repo); } void test_index_version__v4_uses_path_compression(void) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libgit2-1.0.0/tests/merge/trees/renames.c new/libgit2-1.0.1/tests/merge/trees/renames.c --- old/libgit2-1.0.0/tests/merge/trees/renames.c 2020-04-01 15:49:12.000000000 +0200 +++ new/libgit2-1.0.1/tests/merge/trees/renames.c 2020-06-04 10:46:58.000000000 +0200 @@ -274,3 +274,80 @@ cl_assert(merge_test_index(index, merge_index_entries, 7)); git_index_free(index); } + +void test_merge_trees_renames__cache_recomputation(void) +{ + git_oid blob, binary, ancestor_oid, theirs_oid, ours_oid; + git_merge_options opts = GIT_MERGE_OPTIONS_INIT; + git_buf path = GIT_BUF_INIT; + git_treebuilder *builder; + git_tree *ancestor_tree, *their_tree, *our_tree; + git_index *index; + size_t blob_size; + void *data; + size_t i; + + cl_git_pass(git_oid_fromstr(&blob, "a2d8d1824c68541cca94ffb90f79291eba495921")); + + /* + * Create a 50MB blob that consists of NUL bytes only. It is important + * that this blob is of a special format, most importantly it cannot + * contain more than four non-consecutive newlines or NUL bytes. This + * is because of git_hashsig's inner workings where all files with less + * than four "lines" are deemed to small. + */ + blob_size = 50 * 1024 * 1024; + cl_assert(data = git__calloc(blob_size, 1)); + cl_git_pass(git_blob_create_from_buffer(&binary, repo, data, blob_size)); + + /* + * Create the common ancestor, which has 1000 dummy blobs and the binary + * blob. The dummy blobs serve as potential rename targets for the + * dummy blob. + */ + cl_git_pass(git_treebuilder_new(&builder, repo, NULL)); + for (i = 0; i < 1000; i++) { + cl_git_pass(git_buf_printf(&path, "%"PRIuMAX".txt", i)); + cl_git_pass(git_treebuilder_insert(NULL, builder, path.ptr, &blob, GIT_FILEMODE_BLOB)); + git_buf_clear(&path); + } + cl_git_pass(git_treebuilder_insert(NULL, builder, "original.bin", &binary, GIT_FILEMODE_BLOB)); + cl_git_pass(git_treebuilder_write(&ancestor_oid, builder)); + + /* We now the binary blob in our tree. */ + cl_git_pass(git_treebuilder_remove(builder, "original.bin")); + cl_git_pass(git_treebuilder_insert(NULL, builder, "renamed.bin", &binary, GIT_FILEMODE_BLOB)); + cl_git_pass(git_treebuilder_write(&ours_oid, builder)); + + git_treebuilder_free(builder); + + /* And move everything into a subdirectory in their tree. */ + cl_git_pass(git_treebuilder_new(&builder, repo, NULL)); + cl_git_pass(git_treebuilder_insert(NULL, builder, "subdir", &ancestor_oid, GIT_FILEMODE_TREE)); + cl_git_pass(git_treebuilder_write(&theirs_oid, builder)); + + /* + * Now merge ancestor, ours and theirs. As `git_hashsig` refuses to + * create a hash signature for the 50MB binary file, we historically + * didn't cache the hashsig computation for it. As a result, we now + * started looking up the 50MB blob and scanning it at least 1000 + * times, which takes a long time. + * + * The number of 1000 blobs is chosen in such a way that it's + * noticeable when the bug creeps in again, as it takes around 12 + * minutes on my machine to compute the following merge. + */ + opts.target_limit = 5000; + cl_git_pass(git_tree_lookup(&ancestor_tree, repo, &ancestor_oid)); + cl_git_pass(git_tree_lookup(&their_tree, repo, &theirs_oid)); + cl_git_pass(git_tree_lookup(&our_tree, repo, &ours_oid)); + cl_git_pass(git_merge_trees(&index, repo, ancestor_tree, our_tree, their_tree, &opts)); + + git_treebuilder_free(builder); + git_buf_dispose(&path); + git_index_free(index); + git_tree_free(ancestor_tree); + git_tree_free(their_tree); + git_tree_free(our_tree); + git__free(data); +} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libgit2-1.0.0/tests/online/clone.c new/libgit2-1.0.1/tests/online/clone.c --- old/libgit2-1.0.0/tests/online/clone.c 2020-04-01 15:49:12.000000000 +0200 +++ new/libgit2-1.0.1/tests/online/clone.c 2020-06-04 10:46:58.000000000 +0200 @@ -11,6 +11,7 @@ #define BB_REPO_URL "https://[email protected]/libgit2/testgitrepository.git"; #define BB_REPO_URL_WITH_PASS "https://libgit3:[email protected]/libgit2/testgitrepository.git"; #define BB_REPO_URL_WITH_WRONG_PASS "https://libgit3:[email protected]/libgit2/testgitrepository.git"; +#define GOOGLESOURCE_REPO_URL "https://chromium.googlesource.com/external/github.com/sergi/go-diff"; #define SSH_REPO_URL "ssh://github.com/libgit2/TestGitRepository" @@ -462,6 +463,13 @@ git_repository_free(g_repo); g_repo = NULL; cl_fixture_cleanup("./foo"); } + +void test_online_clone__googlesource(void) +{ + cl_git_pass(git_clone(&g_repo, GOOGLESOURCE_REPO_URL, "./foo", &g_options)); + git_repository_free(g_repo); g_repo = NULL; + cl_fixture_cleanup("./foo"); +} static int cancel_at_half(const git_indexer_progress *stats, void *payload) {
