public void CanInvokePrePushCallbackAndFail()
{
bool packBuilderCalled = false;
bool prePushHandlerCalled = false;
PackBuilderProgressHandler packBuilderCb = (x, y, z) => { packBuilderCalled = true; return true; };
PrePushHandler prePushHook = (IEnumerable<PushUpdate> updates) =>
{
Assert.True(updates.Count() == 1, "Expected 1 update, received " + updates.Count());
prePushHandlerCalled = true;
return false;
};
AssertPush(repo => repo.Network.Push(repo.Head));
AssertPush(repo => repo.Network.Push(repo.Branches["master"]));
PushOptions options = new PushOptions()
{
OnPushStatusError = OnPushStatusError,
OnPackBuilderProgress = packBuilderCb,
OnNegotiationCompletedBeforePush = prePushHook
};
Assert.Throws<UserCancelledException>(() => { AssertPush(repo => repo.Network.Push(repo.Network.Remotes["origin"], "HEAD", @"refs/heads/master", options)); });
Assert.False(packBuilderCalled);
Assert.True(prePushHandlerCalled);
}
protected override void OnEnable()
{
base.OnEnable();
pushOptions = new PushOptions()
{
CredentialsProvider = CredentialsHandler, OnPackBuilderProgress = OnPackBuildProgress, OnPushTransferProgress = PushTransferProgress, OnPushStatusError = OnFail, OnNegotiationCompletedBeforePush = GitHookManager.PrePushHandler
};
}
public AppStatePushOperation(PushOptions options, AppState owner, IAppStateTransition t, CancellationToken ct, Type controllerType, object controllerArgs)
: base(t, ct)
{
Options = options;
OwnerState = owner;
ControllerType = controllerType;
ControllerArgs = controllerArgs;
}
private PushOptions getPushOptions(string personalAccessKey)
{
var po = new PushOptions()
{
CustomHeaders = new[] { "Authorization: Bearer " + personalAccessKey }
};
return(po);
}
public void Push()
{
PushOptions options = new PushOptions()
{
CredentialsProvider = (url, usernameFromUrl, types) => GitManager.Token
};
RepositoryManager.LocalRepository.Network.Push(RepositoryManager.LocalRepository.Head, options);
}
public GitClient(IGitHubCredentialProvider credentialProvider)
{
pushOptions = new PushOptions {
CredentialsProvider = credentialProvider.HandleCredentials
};
fetchOptions = new FetchOptions {
CredentialsProvider = credentialProvider.HandleCredentials
};
}
public static async Task ProcessReleaseAsync([ActivityTrigger] Tuple <string, ReleaseInfo> funcParams, TraceWriter log, ExecutionContext context)
{
var(branchName, releaseInfo) = funcParams;
log.Info($"Processing Ghost release: {releaseInfo.ReleaseName}.");
log.Info($"Processing in branch: {branchName}.");
var resourcesPath = context.FunctionAppDirectory;
var repoPath = Path.GetFullPath(Path.Combine(resourcesPath, @"..\Target-" + DateTime.UtcNow.ToString("yyyyMMddTHHmmss")));
try
{
var co = new CloneOptions
{
CredentialsProvider = Settings.Handler,
BranchName = branchName
};
var gitPath = Repository.Clone($"https://github.com/{Settings.GitRepoOwner}/{Settings.GitRepoName}.git", repoPath, co);
using (var repo = new Repository(gitPath))
{
var repoDir = new DirectoryInfo(repoPath);
repoDir.Empty(true);
await repoDir.DownloadGhostVersion(releaseInfo.ReleaseUrl);
repoDir.EnrichPackageJson();
var azureResourcesDir = new DirectoryInfo(Path.Combine(resourcesPath, "AzureDeployment"));
//todo: enrich config.production.json to inject the right db credentials from environment variables before copying.
//todo: update azuredeploy.json with arm templates of new resources like mysql and key vault.
repoDir.InjectConfigSecrets(Settings);
azureResourcesDir.CopyFilesRecursively(repoDir);
Commands.Stage(repo, "*");
var author = new Signature(Settings.GitAuthorName, Settings.GitAuthorEmail, DateTime.Now);
var commit = repo.Commit($"Add v{releaseInfo.ReleaseName}", author, author);
var options = new PushOptions
{
CredentialsProvider = Settings.Handler
};
repo.Network.Push(repo.Branches[branchName], options);
await CreateRelease(releaseInfo.ReleaseName, releaseInfo.ReleaseNotes, branchName);
}
}
catch (Exception e)
{
log.Error(e.Message);
log.Error(e.StackTrace);
}
finally
{
log.Info($"Finished processing Ghost release: {releaseInfo.ReleaseName}.");
}
}
public void PushToRemote(string branchName, CredentialsHandler GitCredentialsHandler)
{
Branch branch = repository.Branches["refs/heads/" + branchName];
var pushOptions = new PushOptions()
{
};
pushOptions.CredentialsProvider = GitCredentialsHandler;
repository.Network.Push(branch, pushOptions);
}
/// <summary>
/// Pushes all commits.
/// </summary>
/// <exception cref="System.Exception">Writes exception to the console</exception>
public void PushCommits()
{
string remoteName = this.remoteName, branchName = this.branchName;
using (var repo = new Repository(this.localFolder.FullName))
{
var remote = repo.Network.Remotes.FirstOrDefault(r => r.Name == remoteName);
if (remote == null)
{
repo.Network.Remotes.Add(remoteName, this.repoUrl);
remote = repo.Network.Remotes.FirstOrDefault(r => r.Name == remoteName);
}
var options = new PushOptions
{
CredentialsProvider = (url, usernameFromUrl, types) => this.credentials
};
options.OnPushStatusError += this.PushSatusErrorHandler;
string pushRefs = "refs/heads/testsyed";
Branch branchs = null;
foreach (var branch in repo.Branches)
{
if (branch.FriendlyName.ToLower().Equals(branchName.ToLower()))
{
branchs = branch;
pushRefs = branch.Reference.CanonicalName;
}
}
Singleton.SolutionFileInfoInstance.WebJobsLog.AppendLine(" Pushing Changes to the Repository " + "<br>");
Console.WriteLine(" Pushing Changes to the Repository ");
repo.Network.Push(remote, pushRefs + ":" + pushRefs, options);
try
{
var remoteOrigin = repo.Network.Remotes.FirstOrDefault(r => r.Name == "remotes/origin" + "<br>");
if (remoteOrigin != null)
{
repo.Network.Push(remoteOrigin, pushRefs, options);
}
}
catch (Exception e)
{
Singleton.SolutionFileInfoInstance.WebJobsLog.AppendLine(" " + e.Message + "<br>");
Console.WriteLine(e.Message);
}
Singleton.SolutionFileInfoInstance.WebJobsLog.AppendLine(" " + "Pushed changes" + "<br>");
Console.WriteLine("Pushed changes");
}
}
/// <summary>
/// rename the entry with all the hassle that accompanies it.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void renameToolStripMenuItem_Click(object sender, EventArgs e)
{
// rename the entry
InputBoxValidation validation = delegate(string val)
{
if (val == "")
{
return(Strings.Error_not_empty);
}
if (new Regex(@"[a-zA-Z0-9-\\_]+/g").IsMatch(val))
{
return(Strings.Error_valid_filename);
}
if (File.Exists(cfg["PassDirectory"] + "\\" + @val + ".gpg"))
{
return(Strings.Error_already_exists);
}
return("");
};
string value = dataPass.Rows[dataPass.CurrentCell.RowIndex].Cells[1].Value.ToString();
if (InputBox.Show(Strings.Input_new_name, Strings.Input_new_name_label, ref value, validation) == DialogResult.OK)
{
// parse path
string tmpPath = cfg["PassDirectory"] + "\\" + @value + ".gpg";
Directory.CreateDirectory(Path.GetDirectoryName(tmpPath));
File.Copy(dataPass.Rows[dataPass.CurrentCell.RowIndex].Cells[0].Value.ToString(), tmpPath);
using (var repo = new LibGit2Sharp.Repository(cfg["PassDirectory"]))
{
// add the file
repo.Remove(dataPass.Rows[dataPass.CurrentCell.RowIndex].Cells[0].Value.ToString());
repo.Stage(tmpPath);
// Commit
repo.Commit("password moved", new LibGit2Sharp.Signature("pass4win", "pass4win", System.DateTimeOffset.Now), new LibGit2Sharp.Signature("pass4win", "pass4win", System.DateTimeOffset.Now));
if (cfg["UseGitRemote"] == true && GITRepoOffline == false)
{
//push
toolStripOffline.Visible = false;
var remote = repo.Network.Remotes["origin"];
var options = new PushOptions();
options.CredentialsProvider = (_url, _user, _cred) => new UsernamePasswordCredentials
{
Username = cfg["GitUser"],
Password = DecryptConfig(cfg["GitPass"], "pass4win")
};
var pushRefSpec = @"refs/heads/master";
repo.Network.Push(remote, pushRefSpec, options);
}
}
ResetDatagrid();
}
}
internal Task <IAppState> PushState(AppState ownerState, PushOptions options, Type controllerType, object controllerArgs)
{
Debug.Assert(controllerType != null);
ThrowIfDisposed();
ThrowIfInvalidControllerType(controllerType);
var op = new AppStatePushOperation(options, ownerState, null, _cancellationSource.Token, controllerType, controllerArgs);
AddStackOperation(op);
RunStackOperation(op);
return(op.Task);
}
private void SetupRepo()
{
using (var repo = new Repository(_localRepoPath))
{
var author = repo.Config.BuildSignature(DateTimeOffset.Now);
repo.Flow().Init(new GitFlowRepoSettings(), author);
TestHelpers.AddCommitToRepo(repo);
PushOptions options = new PushOptions();
Remote remote = repo.Network.Remotes["origin"];
repo.Network.Push(repo.Head);
}
}
private void Push()
{
using (var repo = new LibGit2Sharp.Repository(RepositoryRootFolder))
{
PushOptions options = new PushOptions();
options.OnPushStatusError += ErrorOnppush;
options.CredentialsProvider = GetSourceCredentialsHandler();
Branch currentBranch = repo.Branches.Where(x => x.FriendlyName == SourceControlBranch).FirstOrDefault();
repo.Network.Push(currentBranch, options);
}
}
public async Task <string> Request()
{
// Credentials
LibGit2Sharp.Handlers.CredentialsHandler credsProvider = (_url, _user, _cred) =>
new UsernamePasswordCredentials
{
Username = opts.GitTokenUser,
Password = opts.GitToken,
};
// Clone
var cloneOpts = new CloneOptions
{
CredentialsProvider = credsProvider,
BranchName = opts.ManifestBaseBranch,
RecurseSubmodules = true
};
var repoDir = Path.Combine(opts.WorkDir, opts.ManifestRepoName);
Repository.Clone(opts.ManifestUri.ToString(), repoDir, cloneOpts);
using (var repo = new Repository(repoDir))
{
// Branch for PR
var branch = repo.CreateBranch(opts.ManifestDeployBranch);
branch = Commands.Checkout(repo, opts.ManifestDeployBranch);
// Update manifest
referenceUpdater.Update();
// Add
Commands.Stage(repo, "*");
// Commit
opts.GitCommitMsg = TemplateUtil.Apply(opts, opts.GitCommitMsgTemplate);
var author = new Signature(opts.GitUser, opts.GitEmail, DateTime.Now);
var committer = author;
var commit = repo.Commit(opts.GitCommitMsg, author, committer);
// Push
var pushOpts = new PushOptions
{
CredentialsProvider = credsProvider
};
repo.Branches.Update(branch,
b => b.Remote = "origin",
b => b.UpstreamBranch = branch.CanonicalName);
repo.Network.Push(branch, pushOpts);
}
return(await deployRequestCreator.Create());
}
//---------------------------------------------------------------------------------
/// <summary>
/// Runs the equivalent of git push
/// </summary>
//---------------------------------------------------------------------------------
public void Push(string branchName)
{
var output = new List <StackChangeInfo>();
var pushOptions = new PushOptions()
{
CredentialsProvider = SupplyUserCredentials
};
var branch = GetBranch(branchName);
// we always push to the same remote counterpart in the remote origin and branch always tracks the previous stack branch if present else master
LocalRepository.Network.Push(LocalRepository.Network.Remotes["origin"], $"{REFS_HEAD}{branchName}", pushOptions);
}
public static Task PushMaster(ToolArgs a, EditySettings editySettings)
{
if (editySettings.ProjectMode != ProjectMode.OneRepoPerUser)
{
throw new InvalidOperationException("The project mode must be OneRepoPerUser to use the pushmaster tool");
}
if (a.Args.Count < 1)
{
throw new InvalidOperationException("You must include the destination repository that you want to push to.");
}
var log = a.Scope.ServiceProvider.GetRequiredService <ILogger <Repository> >();
var destRepo = a.Args[0];
var masterDir = Path.GetFullPath(Path.Combine(editySettings.ProjectPath, "Master"));
if (!Directory.Exists(masterDir))
{
throw new InvalidOperationException($"Master dir {masterDir} does not exist. No push will occur.");
}
var syncDir = Path.GetFullPath(Path.Combine(editySettings.ProjectPath, "Sync"));
if (!Directory.Exists(syncDir))
{
throw new InvalidOperationException($"Sync dir {syncDir} does not exist. No push will occur.");
}
var syncRepo = new Repository(syncDir);
//Change origin to master and pull changes from Master
log.LogInformation("Pulling from master to sync.");
ChangeRemote(syncRepo, masterDir);
var result = Commands.Pull(syncRepo, new Signature("syncbot", "syncbot@syncbot", DateTime.Now), new PullOptions());
//Change origin to new desitination and push
ChangeRemote(syncRepo, destRepo);
//Push to dest
var remote = syncRepo.Network.Remotes[origin];
var options = new PushOptions()
{
CredentialsProvider = (url, user, cred) => GetCredentials(a)
};
foreach (var branch in syncRepo.Branches.Where(i => !i.IsRemote))
{
log.LogInformation($"Pushing branch {branch.CanonicalName} to origin master.");
syncRepo.Network.Push(remote, branch.CanonicalName, options);
}
return(Task.FromResult(0));
}
/// <summary>
/// Push the contents of the package to the remote.
/// </summary>
/// <param name="package">The package to push.</param>
/// <param name="comment">The comment for the commit.</param>
/// <param name="authorName">The author of the commit.</param>
/// <param name="authorEmail">The author's email.</param>
public void PushPackage(byte[] package, string comment)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
Validate();
using (Repository repo = Init(true))
{
PushOptions pushOptions = null;
try
{
string workPath = ParseLocalUrl(RemoteUrl);
bool isLocal = true;
if (workPath == null)
{
workPath = WorkingPath;
isLocal = false;
}
// extract package to the working directory
string path = (!String.IsNullOrWhiteSpace(SubFolder)) ?
Path.Combine(workPath, SubFolder) :
workPath;
string[] files = Package.Extract(package, path, true, false);
// stage, commit, and then push (if not local)
repo.Stage(files);
Signature author = new Signature(AuthorName, AuthorEmail, DateTime.Now);
repo.Commit(comment, author, author);
if (!isLocal)
{
pushOptions = new PushOptions();
pushOptions.CredentialsProvider += ProvideCredentials;
repo.Network.Push(Branch, pushOptions);
}
}
finally
{
if (pushOptions != null)
{
pushOptions.CredentialsProvider -= ProvideCredentials;
}
}
}
}
public void PushInitialCommit(string fullname, string email, string username, string password, string url, string gitignore, string license)
{
var path = GetTemporaryDirectory();
Directory.CreateDirectory(path);
FillAccessories(fullname, email, path, gitignore, license);
if (!LibGit2Sharp.Repository.IsValid(path))
{
LibGit2Sharp.Repository.Init(path);
}
using (var repo = new LibGit2Sharp.Repository(path))
{
if (File.Exists(Path.Combine(path, ".gitignore")))
{
LibGit2Sharp.Commands.Stage(repo, ".gitignore");
}
if (File.Exists(Path.Combine(path, "LICENSE")))
{
LibGit2Sharp.Commands.Stage(repo, "LICENSE");
}
// Create the committer's signature and commit
Signature author = new Signature(fullname, email, DateTime.Now);
Signature committer = author;
// Commit to the repository
Commit commit = repo.Commit("Initial commit", author, committer);
//var options = new LibGit2Sharp.PushOptions()
//{
// CredentialsProvider = (url, usernameFromUrl, types) =>
// new UsernamePasswordCredentials()
// {
// Username = email,
// Password = password
// }
//};
//repo.Network.Push(repo.Branches["master"], options);
repo.Network.Remotes.Add("origin", url);
var remote = repo.Network.Remotes["origin"];
var options = new PushOptions();
options.CredentialsProvider = (_url, _user, _cred) =>
new UsernamePasswordCredentials {
Username = (string.IsNullOrEmpty(username) ? email : username), Password = password
};
repo.Network.Push(remote, @"refs/heads/master", options);
}
DeleteDirectory(path);
}
public void Push()
{
var pushOptions = new PushOptions();
pushOptions.CredentialsProvider = new LibGit2Sharp.Handlers.CredentialsHandler(
(_url, _user, _cred) => new UsernamePasswordCredentials()
{
Username = this.username,
Password = this.password
});
repo.Network.Push(repo.Branches["master"], pushOptions);
}
public async Task Push(string configurationId, string payload, PushOptions options)
{
var config = await pushConfigurationStore.GetAsync(configurationId);
try
{
await(await CreateProvider(config)).PushAsync(payload, options);
}
catch (Exception e)
{
throw new PushFailedException(config, e);
}
}
public async Task PushAsync(string payload, PushOptions opts)
{
object objData = null;
try
{
objData = JsonConvert.DeserializeObject(payload);
}
catch
{
}
await firebaseHttpClient.Push(options.ServerKey, endpoint.Endpoint, objData ?? payload, opts?.Urgency);
}
public static async Task CommitAllChanges(string message, string filePath, string cloneUrl)
{
try
{
Console.WriteLine("Commit all changes to GitHub.");
var _folder = new DirectoryInfo(filePath);
string path = LibGit2Sharp.Repository.Init(_folder.FullName);
using (var repo = new LibGit2Sharp.Repository(path))
{
var files = _folder.GetFiles("*", SearchOption.AllDirectories).Select(f => f.FullName);
Commands.Stage(repo, "*");
repo.Commit(message, new LibGit2Sharp.Signature("sormita", "*****@*****.**", DateTimeOffset.Now),
new LibGit2Sharp.Signature("sormita", "*****@*****.**", DateTimeOffset.Now));
//push files
string name = "origin";
repo.Network.Remotes.Add(name, cloneUrl);
var remote = repo.Network.Remotes.FirstOrDefault(r => r.Name == name);
var options = new PushOptions
{
CredentialsProvider = (_url, _user, _cred) =>
new UsernamePasswordCredentials {
Username = "******", Password = "******"
}
};
var fetchOptions = new FetchOptions
{
CredentialsProvider = (_url, _user, _cred) =>
new UsernamePasswordCredentials {
Username = "******", Password = "******"
}
};
string pushRefSpec = @"+refs/heads/master";
List <string> fetchString = new List <string>();
fetchString.Add(pushRefSpec);
repo.Network.Fetch("origin", fetchString, fetchOptions);
repo.Network.Push(remote, pushRefSpec, options);
}
}
catch (Exception ex)
{
throw;
}
}
private void CheckOnline(bool silent = false)
{
// Is remote on in the config
if (cfg["UseGitRemote"])
{
// Check if the remote is there
if (IsGITAlive(cfg["GitRemote"]) || IsHTTPSAlive(cfg["GitRemote"]))
{
// looks good, let's try
GITRepoOffline = false;
}
// Do a fetch to get the latest repo.
if (!GitFetch())
{
// nope not online
GITRepoOffline = true;
MessageBox.Show(Strings.Error_connection, Strings.Error, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
// We're online
toolStripOffline.Visible = false;
// look if we have changes we should sync
using (var repo = new LibGit2Sharp.Repository(cfg["PassDirectory"]))
{
TreeChanges tc = repo.Diff.Compare <TreeChanges>(repo.Branches["origin/master"].Tip.Tree, repo.Head.Tip.Tree);
if (tc.Count() > 0)
{
var remote = repo.Network.Remotes["origin"];
var options = new PushOptions();
options.CredentialsProvider = (_url, _user, _cred) => new UsernamePasswordCredentials
{
Username = cfg["GitUser"],
Password = DecryptConfig(cfg["GitPass"], "pass4win")
};
var pushRefSpec = @"refs/heads/master";
repo.Network.Push(remote, pushRefSpec, options);
}
}
}
}
else
{
// no remote checkbox so we're staying offline
if (!silent)
{
MessageBox.Show(Strings.Error_remote_disabled, Strings.Error, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
public void PushWithLicense(string fullname, string email, string username, string password, string url, string path, string license)
{
if (!LibGit2Sharp.Repository.IsValid(path))
{
LibGit2Sharp.Repository.Init(path);
}
using (var repo = new LibGit2Sharp.Repository(path))
{
if (!string.IsNullOrEmpty(license))
{
try
{
FillAccessories(fullname, email, path, null, license);
LibGit2Sharp.Commands.Stage(repo, "LICENSE");
// Create the committer's signature and commit
Signature author = new Signature(fullname, email, DateTime.Now);
Signature committer = author;
// Commit to the repository
Commit commit = repo.Commit($"Use {license}", author, committer);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
if (repo.Network.Remotes.Any(r => r.Name == "origin"))
{
repo.Network.Remotes.Remove("origin");
}
repo.Network.Remotes.Add("origin", url);
var remote = repo.Network.Remotes["origin"];
var options = new PushOptions();
options.CredentialsProvider = (_url, _user, _cred) =>
new UsernamePasswordCredentials {
Username = (string.IsNullOrEmpty(username) ? email : username), Password = password
};
Branch current = repo.Branches.Where(b => b.IsCurrentRepositoryHead).FirstOrDefault();
repo.Network.Push(remote, current.CanonicalName, options); //@"refs/heads/master", options);
Branch remoteBranch = repo.Branches.Where(b => b.FriendlyName.EndsWith(current.FriendlyName) && b.IsRemote).FirstOrDefault();
repo.Branches.Update(current, bu => {
bu.Remote = remoteBranch.RemoteName;
bu.TrackedBranch = remoteBranch.CanonicalName;
bu.UpstreamBranch = remoteBranch.UpstreamBranchCanonicalName;
});
}
}
private static void Push(Repository repo, IEnumerable <Remote> remotes,
bool useCredentials, string username, string email,
string pwd)
{
var branches = repo.Branches
.Where(b => b.Remote != null &&
remotes.Any(r => r.Name == b.Remote.Name));
foreach (var b in branches)
{
try
{
GlobalConsole.Current
.InvokeForConsoleColor((c, s) => c.Write(" [PUSH] Branch '{0}' to remote '{1}'... ",
s.Branch.Name,
s.Remote.Name),
new
{
Branch = b,
Remote = b.Remote,
});
var pushOpts = new PushOptions();
if (useCredentials)
{
pushOpts.Credentials = new Credentials()
{
Username = username,
Password = pwd,
};
}
repo.Network.Push(b.Remote, "HEAD", b.CanonicalName, pushOpts);
GlobalConsole.Current
.InvokeForConsoleColor((c) => c.WriteLine("[OK]"),
foreColor: ConsoleColor.Green);
}
catch (Exception ex)
{
GlobalConsole.Current
.InvokeForConsoleColor((c, s) => c.WriteLine(s.Exception),
new
{
Exception = ex.GetBaseException() ?? ex,
}, foreColor: ConsoleColor.Red);
}
}
}
internal static void CommitAllChanges(string repoPath, string commitMessage, string user, string email)
{
using var repo = new Repository(repoPath);
Commands.Stage(repo, "*");
var author = new Signature(user, email, DateTime.Now);
var committer = author;
var commit = repo.Commit(commitMessage, author, committer);
var options = new PushOptions
{
CredentialsProvider = GetCredentialsHandler()
};
repo.Network.Push(repo.Branches[Branch], options);
}
private void PushToRepo()
{
using (var repo = new Repository(HighScorePath))
{
var options = new PushOptions
{
CredentialsProvider = (url, usernameFromUrl, types) =>
new UsernamePasswordCredentials {
Username = UserName, Password = Token
}
};
repo.Network.Push(repo.Branches[BranchName], options);
}
}
private void Push(Repository activeRepository)
{
var pushOptions = new PushOptions()
{
CredentialsProvider = this.CreateCredentials
};
var remote = activeRepository.Network.Remotes[remoteName];
if (activeRepository.Head?.Commits != null && activeRepository.Head.Commits.Any())
{
activeRepository.Network.Push(remote, "HEAD", @"refs/heads/" + mainBranch, pushOptions);
}
}
public string PushWithStatus(List <LocalMapping> fileMappings, string repoFolderPath)
{
_logger.Info("Making attempt to push to repo");
try
{
SyncFilesToRepo(fileMappings, repoFolderPath);
using (var repo = new Repository(repoFolderPath))
{
foreach (var item in repo.RetrieveStatus(new LibGit2Sharp.StatusOptions()))
{
Console.WriteLine(item.FilePath);
}
var changes = repo.RetrieveStatus(new LibGit2Sharp.StatusOptions());
if (!changes.ToList().Any())
{
return("no changes to push");
}
Commands.Stage(repo, "*");
repo.Index.Write();
// Create the committer's signature and commit
Signature author = new Signature(ConfigurationManager.AppSettings["GitUser"], ConfigurationManager.AppSettings["GitEmail"], DateTime.Now);
Signature committer = author;
// Commit to the repository
Commit commit = repo.Commit($"Saves Update {DateTime.Now.ToShortDateString()}", author, committer);
PushOptions options = new PushOptions();
options.CredentialsProvider = new CredentialsHandler(
(url, usernameFromUrl, types) =>
new UsernamePasswordCredentials()
{
Username = ConfigurationManager.AppSettings["GitEmail"],
Password = ConfigurationManager.AppSettings["GitPassword"]
});
repo.Network.Push(repo.Branches["master"], options);
return("successfully pushed changes to the shared repo");
}
}
catch (Exception e)
{
_logger.Error(e, "failed to push changes");
return("failed to push changes");
}
}
public GitClient(IGitHubCredentialProvider credentialProvider)
{
pushOptions = new PushOptions {
CredentialsProvider = credentialProvider.HandleCredentials
};
fetchOptions = new FetchOptions {
CredentialsProvider = credentialProvider.HandleCredentials
};
pullOptions = new PullOptions
{
FetchOptions = fetchOptions,
MergeOptions = new MergeOptions(),
};
}
public void Push(UsernamePasswordCredentials gitCredentials)
{
Repository repo = new Repository(RepositoryPath);
// Get git credentials
CredentialsHandler credentialsHandler = new CredentialsHandler(
(url, usernameFromUrl, types) => gitCredentials);
// Pull repository
PushOptions options = new PushOptions
{
CredentialsProvider = credentialsHandler
};
repo.Network.Push(repo.Branches["refs/heads/master"], options);
}
public void CanPushABranchTrackingAnUpstreamBranch()
{
bool packBuilderCalled = false;
Handlers.PackBuilderProgressHandler packBuilderCb = (x, y, z) => { packBuilderCalled = true; return true; };
AssertPush(repo => repo.Network.Push(repo.Head));
AssertPush(repo => repo.Network.Push(repo.Branches["master"]));
PushOptions options = new PushOptions()
{
OnPushStatusError = OnPushStatusError,
OnPackBuilderProgress = packBuilderCb,
};
AssertPush(repo => repo.Network.Push(repo.Network.Remotes["origin"], "HEAD", @"refs/heads/master", options));
Assert.True(packBuilderCalled);
}
