clone a git repository using git init, fetch, and checkout - c++

Question

Introduction
I'm doing experimentations using the popular libgit2 written in C.
I'm trying to do a clone but using an un-common way. In order, the git commands:
git init
git remote add origin https://repository.git
git fetch origin
git checkout master
By using git bash and the following commands, I can get an existing repository with all its history.
Question
Now, let's see my current C++ implementation. The following code is trying to copy the behaviour of the previous written git commands.
#define url "https://repository.git"
#define path "./"
#define user "user"
#define pass "pass"
/** credential callback **/
int credentials(git_cred **cred, const char *, const char *, unsigned int, void *) {
return git_cred_userpass_plaintext_new(cred, user, pass);
}
class Git {
public:
Git() {
git_libgit2_init();
}
~Git() {
git_repository_free(repository);
git_libgit2_shutdown();
}
void update() {
init();
fetch();
checkout();
}
private:
void init() {
assertSuccess(git_repository_init(&repository, path, GIT_CVAR_FALSE));
git_remote *remote = nullptr;
git_remote_callbacks options = GIT_REMOTE_CALLBACKS_INIT;
assertSuccess(git_remote_create(&remote, repository, "origin", url));
options.credentials = credentials;
git_remote_connect(remote, GIT_DIRECTION_FETCH, &options, nullptr, nullptr);
}
void fetch() {
git_remote* remote = nullptr;
assertSuccess(git_remote_lookup(&remote, repository, "origin"));
git_fetch_options options = GIT_FETCH_OPTIONS_INIT;
options.callbacks.credentials = credentials;
assertSuccess(git_remote_fetch(remote, nullptr, &options, nullptr));
}
void checkout() {
git_checkout_options options = GIT_CHECKOUT_OPTIONS_INIT;
options.checkout_strategy = GIT_CHECKOUT_FORCE;
assertSuccess(git_checkout_head(repository, &options));
assertSuccess(git_checkout_index(repository, nullptr, &options));
assertSuccess(git_repository_set_head(repository, "refs/heads/master"));
git_object *treeish = nullptr;
assertSuccess(git_revparse_single(&treeish, repository, "master"));
assertSuccess(git_checkout_tree(repository, treeish, &options));
}
void assertSuccess(int error) {
if (!error) return;
const git_error *e = giterr_last();
std::cout << "code: " << e->klass << " error: " << e->message << std::endl;
exit(1);
}
private:
git_repository *repository = nullptr;
};
int main() {
Git git;
git.update();
return 0;
}
Obviously, this does not work. Running this program (calling Git().update()), I'm getting the following error during the checkout step:
code: 4 error: reference 'refs/heads/master' not found
The git repository has been created and I can see the remote origin that has been set successfully though git bash. I can do a manual git checkout master from git bash so I guess my current implementation of checkout is a failure.
Could someone highlight me about this error? I couldn't find enough resources nor support on all found example on internet.
EDIT
Since testing my code might help, let me give my CMakeLists.txt for compile libgit2. (source code https://github.com/libgit2/libgit2)
cmake_minimum_required(VERSION 3.13)
project(test)
include_directories(libgit/include)
LINK_DIRECTORIES(${LIBSSH2_LIBRARY_DIRS})
add_subdirectory(libgit)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_BUILD_TYPE Release)
add_executable(test src/Git.h)
target_link_libraries(test git2)

Answer 1

The missing link is that, since you're building a repository from scratch, your repository is still unborn (ie, its HEAD points to a non-existent refs/heads/master ref). On top of that, checkout's only concern in libgit2-land is about bringing out files from the ODB, it doesn't write or update references.
Hence, you are missing the step where git checkout uses (in all likelihood) git update-ref to make master point to origin/master's OID, and you can do that via git_reference_create and friends.
Something like the following (brain-compiled):
static int setup_tracking_branch(char *branch_name, git_reference *upstream)
{
git_reference *tracking;
git_oid up_oid = git_reference_target_peel(upstream);
char *ui_name;
#if 0
/* should be constructed from `upstream`. IIRC there are some
* git_reference accessors that can help
* (eg. `refs/remotes/origin/heads/master` is `origin/master`).
*/
#else
ui_name = "origin/master";
#endif
if (git_reference_create_matching(&tracking,
git_reference_owner(upstream),
branch_name, up_oid, 0, NULL, "branch: created from %s", ui_name) < 0 ||
git_branch_set_upstream(tracking, git_reference_name(upstream)) < 0) {
printf("failed to create remote-tracking branch\n");
return -1;
}
cleanup:
git_reference_free(tracking);
return 0;
}
This takes the name you want the new branch to be (-b), and the remote branch to track (-t), though it is clearly not a complete reimplementation, or even correct, so YMMV.