/// <summary>
/// Update specified submodule.
/// <para>
/// This will:
/// 1) Optionally initialize the if it not already initialzed,
/// 2) clone the sub repository if it has not already been cloned, and
/// 3) checkout the commit ID for the submodule in the sub repository.
/// </para>
/// </summary>
/// <param name="name">The name of the submodule to update.</param>
/// <param name="options">Options controlling submodule udpate behavior and callbacks.</param>
public virtual void Update(string name, SubmoduleUpdateOptions options)
{
options = options ?? new SubmoduleUpdateOptions();
using (var handle = Proxy.git_submodule_lookup(repo.Handle, name))
{
if (handle == null)
{
throw new NotFoundException("Submodule lookup failed for '{0}'.",
name);
}
using (GitCheckoutOptsWrapper checkoutOptionsWrapper = new GitCheckoutOptsWrapper(options))
{
var gitCheckoutOptions = checkoutOptionsWrapper.Options;
var remoteCallbacks = new RemoteCallbacks(options);
var gitRemoteCallbacks = remoteCallbacks.GenerateCallbacks();
var gitSubmoduleUpdateOpts = new GitSubmoduleUpdateOptions
{
Version = 1,
CheckoutOptions = gitCheckoutOptions,
FetchOptions = new GitFetchOptions {
ProxyOptions = new GitProxyOptions {
Version = 1
}, RemoteCallbacks = gitRemoteCallbacks
},
CloneCheckoutStrategy = CheckoutStrategy.GIT_CHECKOUT_SAFE
};
Proxy.git_submodule_update(handle, options.Init, ref gitSubmoduleUpdateOpts);
}
}
}
/// <summary>
/// Push specified references to the <see cref="Remote"/>.
/// </summary>
/// <param name="remote">The <see cref="Remote"/> to push to.</param>
/// <param name="pushRefSpecs">The pushRefSpecs to push.</param>
/// <param name="pushOptions"><see cref="PushOptions"/> controlling push behavior</param>
public virtual void Push(Remote remote, IEnumerable <string> pushRefSpecs, PushOptions pushOptions)
{
Ensure.ArgumentNotNull(remote, "remote");
Ensure.ArgumentNotNull(pushRefSpecs, "pushRefSpecs");
// Return early if there is nothing to push.
if (!pushRefSpecs.Any())
{
return;
}
if (pushOptions == null)
{
pushOptions = new PushOptions();
}
// Load the remote.
using (RemoteHandle remoteHandle = Proxy.git_remote_lookup(repository.Handle, remote.Name, true))
{
var callbacks = new RemoteCallbacks(pushOptions);
GitRemoteCallbacks gitCallbacks = callbacks.GenerateCallbacks();
Proxy.git_remote_push(remoteHandle,
pushRefSpecs,
new GitPushOptions()
{
PackbuilderDegreeOfParallelism = pushOptions.PackbuilderDegreeOfParallelism,
RemoteCallbacks = gitCallbacks,
ProxyOptions = new GitProxyOptions {
Version = 1
},
});
}
}
/// <summary>
/// Perform a fetch
/// </summary>
/// <param name="repository">The repository in which to fetch.</param>
/// <param name="remote">The remote to fetch from. Either as a remote name or a URL</param>
/// <param name="options">Fetch options.</param>
/// <param name="logMessage">Log message for any ref updates.</param>
/// <param name="refspecs">List of refspecs to apply as active.</param>
public static void Fetch(Repository repository, string remote, IEnumerable <string> refspecs, FetchOptions options, string logMessage)
{
Ensure.ArgumentNotNull(remote, "remote");
options = options ?? new FetchOptions();
using (var remoteHandle = RemoteFromNameOrUrl(repository.Handle, remote))
using (var fetchOptionsWrapper = new GitFetchOptionsWrapper())
{
var callbacks = new RemoteCallbacks(options);
GitRemoteCallbacks gitCallbacks = callbacks.GenerateCallbacks();
// It is OK to pass the reference to the GitCallbacks directly here because libgit2 makes a copy of
// the data in the git_remote_callbacks structure. If, in the future, libgit2 changes its implementation
// to store a reference to the git_remote_callbacks structure this would introduce a subtle bug
// where the managed layer could move the git_remote_callbacks to a different location in memory,
// but libgit2 would still reference the old address.
//
// Also, if GitRemoteCallbacks were a class instead of a struct, we would need to guard against
// GC occuring in between setting the remote callbacks and actual usage in one of the functions afterwords.
var fetchOptions = fetchOptionsWrapper.Options;
fetchOptions.RemoteCallbacks = gitCallbacks;
fetchOptions.download_tags = Proxy.git_remote_autotag(remoteHandle);
if (options.TagFetchMode.HasValue)
{
fetchOptions.download_tags = options.TagFetchMode.Value;
}
if (options.Prune.HasValue)
{
fetchOptions.Prune = options.Prune.Value ? FetchPruneStrategy.Prune : FetchPruneStrategy.NoPrune;
}
else
{
fetchOptions.Prune = FetchPruneStrategy.FromConfigurationOrDefault;
}
if (options.CustomHeaders != null && options.CustomHeaders.Length > 0)
{
fetchOptions.CustomHeaders = GitStrArrayManaged.BuildFrom(options.CustomHeaders);
}
fetchOptions.ProxyOptions = new GitProxyOptions {
Version = 1
};
Proxy.git_remote_fetch(remoteHandle, refspecs, fetchOptions, logMessage);
}
}
private IEnumerable <Reference> ListReferencesInternal(string url, CredentialsHandler credentialsProvider)
{
using (RemoteHandle remoteHandle = BuildRemoteHandle(repository.Handle, url))
{
GitRemoteCallbacks gitCallbacks = new GitRemoteCallbacks {
version = 1
};
GitProxyOptions proxyOptions = new GitProxyOptions {
Version = 1
};
if (credentialsProvider != null)
{
var callbacks = new RemoteCallbacks(credentialsProvider);
gitCallbacks = callbacks.GenerateCallbacks();
}
Proxy.git_remote_connect(remoteHandle, GitDirection.Fetch, ref gitCallbacks, ref proxyOptions);
return(Proxy.git_remote_ls(repository, remoteHandle));
}
}
