protected Branch Pull(Branch branch, MergeOptions mergeOptions)
{
var signature = new Signature(name: "PineBlog GitDb", email: "*****@*****.**", new DateTimeOffset(DateTime.UtcNow));
var fetchOptions = new FetchOptions {
CredentialsProvider = new CredentialsHandler((url, usernameFromUrl, types) => _credentials)
};
var pullOptions = new PullOptions();
pullOptions.FetchOptions = fetchOptions;
pullOptions.MergeOptions = mergeOptions;
if (branch.IsRemote)
{
var localBranch = _repository.Branches.SingleOrDefault(b => !b.IsRemote && b.CanonicalName == branch.CanonicalName);
if (localBranch == null)
{
var branchName = branch.CanonicalName.Substring(branch.CanonicalName.IndexOf("origin/") + "origin/".Length);
localBranch = _repository.CreateBranch(branchName, branch.Tip);
_repository.Branches.Update(localBranch, b => b.TrackedBranch = branch.CanonicalName);
localBranch = _repository.Branches[branchName];
}
branch = localBranch;
}
// set active branch
Commands.Checkout(_repository, branch);
Commands.Pull(_repository, signature, pullOptions);
return(branch);
}
/// <summary>
/// This will ensure that the docs exist, this checks by the existence of the /Documentation/sitemap.js file
/// </summary>
public void EnsureGitHubDocs()
{
if (Directory.Exists(_rootFolderPath) == false)
{
Directory.CreateDirectory(_rootFolderPath);
}
if (Directory.Exists(Path.Combine(_rootFolderPath, ".git")))
{
using (var repo = new LibGit2Sharp.Repository(_rootFolderPath))
{
var options = new PullOptions {
FetchOptions = new FetchOptions()
};
var signature = new Signature("Our Umbraco", "*****@*****.**", new DateTimeOffset(DateTime.Now));
Commands.Pull(repo, signature, options);
}
}
else
{
// clone if the repo doesn't yet exist
LibGit2Sharp.Repository.Clone("https://github.com/umbraco/UmbracoDocs", _rootFolderPath);
}
BuildSitemap(_rootFolderPath);
//YUCK, this is horrible but unfortunately the way that the doc indexes are setup are not with
// a consistent integer id per document. I'm sure we can make that happen but I don't have time right now.
ExamineManager.Instance.IndexProviderCollection["documentationIndexer"].RebuildIndex();
}
/// <summary>
/// 生成Pull参数
/// </summary>
/// <param name="userName">用户名</param>
/// <param name="email">邮箱</param>
/// <param name="password">密码</param>
/// <returns>Pull参数</returns>
private PullOptions GetPullOptions(string userName, string email, string password)
{
FetchOptions fetchOptions = new FetchOptions();
fetchOptions.OnProgress = (output) =>
{
EditorUtility.DisplayProgressBar("Fetch", output, 0);
return(true);
};
fetchOptions.CredentialsProvider = (url, usernameFromUrl, types) =>
{
return(new UsernamePasswordCredentials {
Username = userName, Password = password
});
};
MergeOptions mergeOptions = new MergeOptions();
mergeOptions.OnCheckoutProgress = (path, completedSteps, totalSteps) =>
{
EditorUtility.DisplayProgressBar("Checkout", path, (float)completedSteps / totalSteps);
};
PullOptions pullOptions = new PullOptions();
pullOptions.FetchOptions = fetchOptions;
pullOptions.MergeOptions = mergeOptions;
return(pullOptions);
}
/// <summary>
/// Méthode qui réalise la commande pull de Git
/// Cette méthode prend en priorité le fichier sur le serveur
/// en cas de conflit
/// </summary>
public void pullContent()
{
if (_gitRepoIsOk)
{
try
{
RepositoryStatus repoStatus = _repository.RetrieveStatus();
if (!repoStatus.IsDirty)
{
PullOptions pullOptions = new PullOptions()
{
MergeOptions = new MergeOptions()
{
FastForwardStrategy = FastForwardStrategy.Default,
FileConflictStrategy = CheckoutFileConflictStrategy.Theirs
}
};
LibGit2Sharp.Commands.Pull(_repository, _signature, pullOptions);
}
}
catch (Exception e)
{
Console.WriteLine("Error PULL : \n" + e.ToString());
}
}
}
public void PullIn()
{
try
{
Identity id = new Identity(GitUser, GitEMail);
Signature sig = new Signature(id, DateTimeOffset.Now);
repo = new Repository(baseDir);
PullOptions options = new PullOptions
{
FetchOptions = new FetchOptions()
};
options.FetchOptions.CredentialsProvider = new CredentialsHandler(
(url, usernameFromUrl, types) =>
new UsernamePasswordCredentials()
{
Username = GitLoginUser,
Password = GitLoginPass
});
Commands.Pull(repo, sig, options);
//repo.Network.Pull(new LibGit2Sharp.Signature("kummerwu", "*****@*****.**", new DateTimeOffset(DateTime.Now)), options);
}catch (Exception e)
{
Logger.E(e);
}
}
static void Pull()
{
var repo = new Repository("Pad");
// Credential information to fetch
PullOptions options = new PullOptions();
options.FetchOptions = new FetchOptions();
options.FetchOptions.CredentialsProvider = new CredentialsHandler(
(url, usernameFromUrl, types) =>
new UsernamePasswordCredentials()
{
Username = "******",
Password = ""
});
// User information to create a merge commit
var signature = new LibGit2Sharp.Signature(
new Identity("npangunion", "*****@*****.**"), DateTimeOffset.Now);
// Pull
var mergeResult = Commands.Pull(repo, signature, options);
Console.WriteLine(mergeResult.Status);
if (mergeResult.Commit != null)
{
Console.WriteLine(mergeResult.Commit.Message);
}
}
public void Pull(string path, string branchMane, string authorName, string authorEmail)
{
using (var repo = new Repository(path))
{
var trackingBranch = repo.Branches[$"remotes/origin/{branchMane}"];
if (trackingBranch.IsRemote)
{
var branch = repo.Head;
repo.Branches.Update(branch, b => b.TrackedBranch = trackingBranch.CanonicalName);
}
PullOptions pullOptions = new PullOptions()
{
MergeOptions = new MergeOptions()
{
FastForwardStrategy = FastForwardStrategy.Default
}
};
MergeResult mergeResult = Commands.Pull(
repo,
new Signature(authorName, authorEmail, DateTimeOffset.Now),
pullOptions
);
}
}
private void UpdateLocal()
{
using var repo = new Repository(_providerOptions.LocalPath);
var options = new PullOptions
{
FetchOptions = new FetchOptions
{
CredentialsProvider = _credentialsHandler
}
};
var signature = new Signature(new Identity("Configuration Service", "Configuration Service"), DateTimeOffset.Now);
_logger.LogInformation("Pulling changes to local repository.");
var currentHash = repo.Head.Tip.Sha.Substring(0, 6);
_logger.LogInformation("Current HEAD is [{currentHash}] '{MessageShort}'.", currentHash, repo.Head.Tip.MessageShort);
var result = Commands.Pull(repo, signature, options);
_logger.LogInformation("Merge completed with status {Status}.", result.Status);
var newHash = result.Commit.Sha.Substring(0, 6);
_logger.LogInformation("New HEAD is [{newHash}] '{MessageShort}'.", newHash, result.Commit.MessageShort);
}
protected virtual void HandleFixedVersioning_Branch(Dependency dependency, Repository otherRepository)
{
Log($"Dependency {dependency}: fixed versioning: checking current HEAD branch...");
var headBranch = otherRepository.Head.FriendlyName;
if (headBranch != dependency.Branch)
{
Log($"Dependency {dependency}: fixed versioning: the current HEAD branch '{headBranch}' is different than the dependency branch '{dependency.Branch}' => checkout");
otherRepository.Checkout(dependency.Branch, new CheckoutOptions()
{
CheckoutModifiers = CheckoutModifiers.Force
});
}
// TODO: perform the pull only when necessary
Log($"Dependency {dependency}: fixed versioning: pulling {dependency.Remote}");
var options = new PullOptions();
options.FetchOptions = new FetchOptions()
{
CredentialsProvider = new CredentialsHandler((url, usernameFromUrl, types) => dependency.GetCredentials(Authentication))
};
otherRepository.Network.Pull(new Signature(dependency.Username, dependency.Email, new DateTimeOffset(DateTime.Now)), options);
}
public void Run(FileRequestResult dataRes)
{
if (dataRes != FileRequestResult.Success)
{
PublishPrice = false;
}
var filterOutFolder = Path.GetTempPath() + "filterGenerationResult";
var repoFolder = filterOutFolder + "\\" + RepoName;
LoggingFacade.LogInfo($"Tempfolder prepared");
if (!Directory.Exists(filterOutFolder))
{
Directory.CreateDirectory(filterOutFolder);
}
// clone/pull the repo. after that, we will edit these existing files by generating the new versions
// and push the update as the actual small changes.
if (Directory.Exists(repoFolder))
{
LoggingFacade.LogInfo($"Repo folder existing... pulling");
RunCommand(filterOutFolder, "git", "branch --set-upstream-to=origin/master master");
using (var repo = new Repository(repoFolder))
{
var options = new PullOptions();
var author = Environment.GetEnvironmentVariable("author", EnvironmentVariableTarget.Process) ?? "FilterPolishZ";
var email = Environment.GetEnvironmentVariable("email", EnvironmentVariableTarget.Process) ?? "FilterPolishZ";
Commands.Pull(repo, new Signature(author, email, DateTimeOffset.Now), options);
LoggingFacade.LogInfo($"Pulling done");
}
}
else
{
LoggingFacade.LogInfo($"Repo folder not existing... cloning");
Repository.Clone("https://github.com/NeverSinkDev/" + RepoName + ".git", repoFolder);
LoggingFacade.LogInfo($"Cloning done!");
}
// create filter
LoggingFacade.LogInfo($"Performing filter generation operations");
FilterWriter.WriteFilter(this.Filter, true, repoFolder + "\\", Path.GetDirectoryName(GenerateFilters.DataFiles.FilterStyleFilesPaths.First().Value) + "\\");
LoggingFacade.LogInfo($"Performing filter generation operations: DONE");
LoggingFacade.LogInfo($"Starting publishing!");
PushToFTP("www", repoFolder, "NeverSink_AutoEcoUpdate_" + GenerateFilters.DataFiles.LeagueType);
LoggingFacade.LogInfo($"Publishing to filterblade: done");
PushToFTP("beta", repoFolder, "NeverSink_AutoEcoUpdate_" + GenerateFilters.DataFiles.LeagueType);
LoggingFacade.LogInfo($"Publishing to filterblade-beta: done");
PushToGit(repoFolder, PublishPrice);
LoggingFacade.LogInfo($"Publishing to GitHub: done");
UploadToPoe(repoFolder);
LoggingFacade.LogInfo($"PoeUpload: done");
// no cleanUp -> we keep this folder here and just pull/push whenever we generate new filters
}
public void PullRemoteChanges(string org, string repository)
{
using (var repo = new Repository(FindLocalRepoLocation(org, repository)))
{
PullOptions pullOptions = new PullOptions()
{
MergeOptions = new MergeOptions()
{
FastForwardStrategy = FastForwardStrategy.Default
}
};
pullOptions.FetchOptions = new FetchOptions();
pullOptions.FetchOptions.CredentialsProvider = (_url, _user, _cred) =>
new UsernamePasswordCredentials {
Username = GetAppToken(), Password = ""
};
MergeResult mergeResult = Commands.Pull(
repo,
new Signature("my name", "my email", DateTimeOffset.Now), // I dont want to provide these
pullOptions
);
}
}
internal static void DescargarVistas(string proyecto)
{
string rutaDirectorio = $"{AppContext.BaseDirectory}Views/{proyecto}";
using (var repo = new Repository(rutaDirectorio))
{
try
{
// Comprobar que la rama actual es la última
string ramaActual = GetActualBranchRepository(proyecto);
Branch rama = FindBranch(ramaActual, repo);
var fetchOptions = new FetchOptions()
{
CredentialsProvider = Credential
};
PullOptions options = new PullOptions();
options.FetchOptions = fetchOptions;
var signature = new LibGit2Sharp.Signature(
new Identity("MERGE_USER_NAME", "MERGE_USER_EMAIL"), DateTimeOffset.Now);
MergeResult merge = Commands.Pull(repo, signature, options);
}
catch (Exception ex)
{
//repo.Info.WorkingDirectory
}
}
}
void DoPull()
{
First = true;
var selected = Program.GetInstance().RemoteManager.SelectedRepositoryRemote;
if (selected == null)
{
Message("No remote to pull from");
}
if (Repository.Info.IsHeadDetached || Repository.Info.IsHeadDetached)
{
Message("No branch to pull");
}
Branch currentBranch = Repository.Head;
Repository.Branches.Update(currentBranch, b => b.Remote = selected.Name, b => b.UpstreamBranch = currentBranch.CanonicalName);
try
{
PullOptions options = new PullOptions()
{
FetchOptions = FetchOptions,
};
Commands.Pull(Repository, Program.GetInstance().UserManager.CurrentSignature, options);
}
catch (NonFastForwardException e)
{
NonFastForwardPush(e.Message);
}
catch (LibGit2SharpException e)
{
ParseGeneralException(e);
}
}
public static GitExecuteResult TryExecute(PullOptions options)
{
var config = Configuration.Load();
var entry = config.Subtrees.FirstOrDefault(c => c.Alias == options.Alias);
if (entry == null)
{
Console.WriteLine($"{options.Alias} not found.");
return(null);
}
if (options.Ref != null)
{
entry.Ref = options.Ref;
}
entry.Squash = options.Squash;
entry.Message = options.Message;
string args = $"{Arguments} {entry}";
var executeResult = new ProcessTool(options, true).ExecuteGit(args);
if (executeResult.ProcessExecutionResult.WasExecuted == false || executeResult.ProcessExecutionResult.ExitCode != 0)
{
Console.WriteLine(executeResult.ProcessExecutionResult.ErrorOutput);
return(executeResult);
}
return(executeResult);
}
private void Pull(Repository repo)
{
Console.WriteLine($"{GIT_TAG} Pulling repo {Name}.");
PullOptions options = new PullOptions
{
FetchOptions = new FetchOptions
{
CredentialsProvider = new CredentialsHandler(
(url, usernameFromUrl, types) =>
new UsernamePasswordCredentials()
{
Username = User,
Password = Password
})
}
};
// User information to create a merge commit
var signature = new Signature(
new Identity(User, Email), DateTimeOffset.Now);
// Pull
Commands.Pull(repo, signature, options);
Console.WriteLine($"{GIT_TAG} Pulled repo {Name}.");
}
public async Task SyncGit()
{
var astroSaves = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Astro", "Saved", "SaveGames");
if (!Directory.Exists(astroSaves))
{
return;
}
var astroSavesRepo = IoC.Get <Repository>("AstroneerRepo");
var signature = new Signature("Astroneer Sync", "*****@*****.**", DateTimeOffset.Now);
var status = astroSavesRepo.RetrieveStatus();
if (status.IsDirty)
{
Commands.Stage(astroSavesRepo, "*");
await ExecuteGitCommand(astroSaves, $"commit -m \"Adding latest changes to save game at {DateTime.Now} from {Environment.UserName}\"");
//astroSavesRepo.Commit($"Adding latest changes to save game at {DateTime.Now} from {Environment.UserName}", signature, signature);
}
var pullOptions = new PullOptions
{
FetchOptions = new FetchOptions {
TagFetchMode = TagFetchMode.Auto
},
MergeOptions = new MergeOptions {
FastForwardStrategy = FastForwardStrategy.Default
}
};
Commands.Pull(astroSavesRepo, signature, pullOptions);
await ExecuteGitCommand(astroSaves, "push");
}
/// <summary>
/// Get's the latest and greatest from remote
/// </summary>
/// <returns></returns>
public bool GitFetch()
{
if (cfg["UseGitRemote"] == true && GITRepoOffline == false)
{
toolStripOffline.Visible = false;
using (var repo = new LibGit2Sharp.Repository(cfg["PassDirectory"]))
{
LibGit2Sharp.Signature Signature = new LibGit2Sharp.Signature("pass4win", "*****@*****.**", new DateTimeOffset(2011, 06, 16, 10, 58, 27, TimeSpan.FromHours(2)));
FetchOptions fetchOptions = new FetchOptions();
fetchOptions.CredentialsProvider = (_url, _user, _cred) => new UsernamePasswordCredentials
{
Username = cfg["GitUser"],
Password = DecryptConfig(cfg["GitPass"], "pass4win")
};
MergeOptions mergeOptions = new MergeOptions();
PullOptions pullOptions = new PullOptions();
pullOptions.FetchOptions = fetchOptions;
pullOptions.MergeOptions = mergeOptions;
try
{
MergeResult mergeResult = repo.Network.Pull(Signature, pullOptions);
}
catch
{
return(false);
}
}
}
return(true);
}
/// <summary>
/// Download data from Johns Hopkins Git repository
/// </summary>
public void DownloadFiles()
{
try
{
using (var repo = new Repository(_repositoryPath))
{
// Credential information to fetch
var options = new PullOptions
{
FetchOptions = new FetchOptions()
};
// User information to create a merge commit
var signature = new Signature(new Identity(_name, _email), DateTimeOffset.Now);
// Pull
var result = Commands.Pull(repo, signature, options);
_logger.Info($"Pull result: {result.Status}");
}
}
catch (Exception e)
{
_logger.Error(e.Message, e);
}
}
public void Pull()
{
var signature = _repository.Config.BuildSignature(DateTimeOffset.UtcNow);
var pullOptions = new PullOptions();
Commands.Pull((Repository)_repository, signature, pullOptions);
}
private async void PullRepositorySolo()
{
try
{
using (var repo = new Repository(CurrentRepository.Info.Path))
{
var gitOpts = EditorVM.AppOptions.GitOptions;
// Credential information to fetch
PullOptions options = new PullOptions();
options.FetchOptions = new FetchOptions();
options.FetchOptions.CredentialsProvider = new CredentialsHandler(
(url, usernameFromUrl, types) =>
new UsernamePasswordCredentials()
{
Username = gitOpts.UserName,
Password = gitOpts.Password
});
// User information to create a merge commit
var signature = new Signature(
new Identity("MERGE_USER_NAME", "MERGE_USER_EMAIL"), DateTimeOffset.Now);
// Pull
Commands.Pull(repo, signature, options);
}
}
catch (Exception e)
{
Console.WriteLine($"Error pulling repository. Error: {e.Message}");
}
}
public bool UpdateLocalProject()
{
try
{
var repo = new Repository(_configProvider.DirectoryCfg.PathProject);
var options = new PullOptions
{
FetchOptions = new FetchOptions
{
CredentialsProvider = (url, usernameFromUrl, types) =>
new UsernamePasswordCredentials()
{
Username = "******", Password = _configProvider.AccessToken.PrivateToken,
}
}
};
// User information to create a merge commit
var signature = new Signature(
new Identity("MERGE_USER_NAME", "MERGE_USER_EMAIL"), DateTimeOffset.Now);
// Pull
var result = Commands.Pull(repo, signature, options);
return(true);
}
catch (Exception e)
{
_logger.Error(e.Message);
return(false);
}
}
/// <summary>
/// git pull
/// </summary>
/// <returns>True if operation was successful.</returns>
public static bool Pull()
{
var config = Config.Load();
try
{
using (var repo = new Repository(config.FullPath))
{
PullOptions options = new PullOptions();
options.FetchOptions = new FetchOptions();
options.FetchOptions.CredentialsProvider = MyCredentialsProvider;
options.MergeOptions = new MergeOptions();
options.MergeOptions.FastForwardStrategy = FastForwardStrategy.FastForwardOnly;
foreach (Remote remote in repo.Network.Remotes)
{
Commands.Pull(repo, GetSignature(config), options);
}
}
}
catch (RepositoryNotFoundException)
{
return(false);
}
return(true);
}
private void UpdateRepo()
{
using (var repo = new Repository(HighScorePath))
{
// Credential information to fetch
var options = new PullOptions
{
FetchOptions = new FetchOptions
{
CredentialsProvider = (url, usernameFromUrl, types) =>
new UsernamePasswordCredentials {
Username = UserName, Password = Token
}
}
};
// User information to create a merge commit
var signature = new Signature(
new Identity(UserName, "@none"), DateTimeOffset.Now);
// Pull
var result = Commands.Pull(repo, signature, options);
if (result.Status == MergeStatus.Conflicts)
{
CheckoutBranch();
ResetRepo();
UpdateRepo();
}
}
}
public void Pull(UsernamePasswordCredentials gitCredentials, Signature signature)
{
Repository repo = new Repository(RepositoryPath);
// Get git credentials
CredentialsHandler credentialsHandler = new CredentialsHandler(
(url, usernameFromUrl, types) => gitCredentials);
// Pull repository
PullOptions pullOptions = new PullOptions
{
FetchOptions = new FetchOptions()
};
pullOptions.FetchOptions.CredentialsProvider = credentialsHandler;
Signature merger = signature;
Commands.Pull(repo, merger, pullOptions);
// Compress changes to zip file
File.Delete(ZipFilePath);
using (ZipArchive zipArchive = ZipFile.Open(ZipFilePath, ZipArchiveMode.Create))
{
foreach (string f in DirSearch(RepositoryPath))
{
zipArchive.CreateEntryFromFile(f, f.Replace(RepositoryPath + @"\", ""));
}
}
}
private void setupOptions(string Username, SecureString SecurePassword, string RepoPath, string RepoUrl)
{
credentials = new SecureUsernamePasswordCredentials()
{
Username = Username, Password = SecurePassword
};
var credentialsProvider =
new CredentialsHandler((_url, _user, _cred) => new SecureUsernamePasswordCredentials
{
Username = Username,
Password = SecurePassword
});
fetchOptions = new FetchOptions()
{
CredentialsProvider = credentialsProvider
};
pullOptions = new PullOptions()
{
FetchOptions = fetchOptions
};
pushOptions = new PushOptions()
{
CredentialsProvider = credentialsProvider
};
cloneOptions = new CloneOptions()
{
CredentialsProvider = credentialsProvider
};
statusOptions = new StatusOptions()
{
ExcludeSubmodules = true, IncludeUnaltered = false
};
}
/// <summary>
/// Pull project
/// </summary>
/// <param name="dir"></param>
/// <param name="userName"></param>
/// <param name="password"></param>
/// <param name="email"></param>
/// <returns></returns>
public bool PullProject(string dir, string userName = null, string password = null, string email = null)
{
using (var repo = new Repository(dir))
{
var options = new PullOptions();
//Create provider
options.FetchOptions = new FetchOptions
{
CredentialsProvider = (url, usernameFromUrl, types) =>
new UsernamePasswordCredentials
{
Username = userName,
Password = password
}
};
//if pull success, create a commit
options.MergeOptions.CommitOnSuccess = true;
//create signature
var signature = new Signature(userName, email, new DateTimeOffset(DateTime.Now));
//pull
repo.Network.Pull(signature, options);
}
return(true);
}
public static GitStatus PullRepo()
{
using (var repo = new Repository(FileUtils.RepoFolder))
{
PullOptions options = new PullOptions
{
FetchOptions = new FetchOptions
{
CredentialsProvider = new CredentialsHandler((_, __, ___)
=> new DefaultCredentials())
}
};
// FIXME not particularly sensitive, but would be nice to extract creds
// if you're viewing this comment in the commit history, hi!
// sneaky, but no sensitive creds here.
MergeResult result = Commands.Pull(repo,
new Signature(Resources.GitName, Resources.GitEmail, new DateTimeOffset(DateTime.Now)), options);
if (result.Status == MergeStatus.FastForward)
{
return(GitStatus.Updated);
}
return(GitStatus.NoUpdates);
}
}
/// <summary>
/// Pull изменений репозитория
/// </summary>
private void PullRepository(string repoPath, UsernamePasswordCredentials credentials)
{
try
{
using var repo = new Repository(repoPath);
var pullOptions = new PullOptions
{
FetchOptions = new FetchOptions
{
Prune = true,
CredentialsProvider = (_url, _user, _cred) => credentials
}
};
var signature = new Signature(
new Identity(_repositoriesConfig.MergeUserName, _repositoriesConfig.MergeUserEmail),
DateTimeOffset.Now);
_logger.LogInformation($"Pulling started: \"{repoPath}\"");
Commands.Pull(repo, signature, pullOptions);
_logger.LogInformation($"Pulling ended: \"{repoPath}\"");
}
catch (Exception ex)
{
_logger.LogError($"Pulling error! Repository: \"{repoPath}\". Message: {ex.Message}");
}
}
/// <inheritDoc />
public virtual async Task PullAsync(PullOptions pullOptions)
{
try
{
string queryName = $"incsync_{typeof(T).Name}";
if (pullOptions == null)
{
await table.PullAsync(queryName, table.CreateQuery());
}
else
{
await table.PullAsync(queryName, table.CreateQuery(), pullOptions);
}
}
catch (MobileServicePushFailedException ex)
{
Debug.WriteLine("PullAsync(): MobileServicePushFailedException hit. Message = " + ex.Message);
if (ex.PushResult != null)
{
foreach (var error in ex.PushResult.Errors)
{
await ResolveConflictAsync(error);
}
}
}
}
/// <summary>
/// Handles a webhook event created by github
/// </summary>
// TODO: Find use for the webhookEvent parameter
public void HandleEvent(GithubWebhookEvent webhookEvent)
{
if (!this.IsCloned)
{
this.Logger?.Debug(
"Cloning repository to {@path}", this.ClonePath.FullName
);
Repository.Clone(this.RepositoryUrl, this.ClonePath.FullName);
this._repository = new Repository(this.ClonePath.FullName);
return;
}
var signature = new Signature(
"Jay", "*****@*****.**", DateTimeOffset.Now
);
var pullOptions = new PullOptions();
var mergeResult = Commands.Pull(
this._repository, signature, pullOptions
);
// This shouldn't really happen since the repo on the server should not be edited directly
if (mergeResult.Status == MergeStatus.Conflicts)
{
this.Logger?.Error(
"Pull operation resulted in a merge conflict"
);
}
}
public void CanPull(FastForwardStrategy fastForwardStrategy)
{
string url = "https://github.com/libgit2/TestGitRepository";
var scd = BuildSelfCleaningDirectory();
string clonedRepoPath = Repository.Clone(url, scd.DirectoryPath);
using (var repo = new Repository(clonedRepoPath))
{
repo.Reset(ResetMode.Hard, "HEAD~1");
Assert.False(repo.RetrieveStatus().Any());
Assert.Equal(repo.Lookup<Commit>("refs/remotes/origin/master~1"), repo.Head.Tip);
PullOptions pullOptions = new PullOptions()
{
MergeOptions = new MergeOptions()
{
FastForwardStrategy = fastForwardStrategy
}
};
MergeResult mergeResult = repo.Network.Pull(Constants.Signature, pullOptions);
if(fastForwardStrategy == FastForwardStrategy.Default || fastForwardStrategy == FastForwardStrategy.FastForwardOnly)
{
Assert.Equal(mergeResult.Status, MergeStatus.FastForward);
Assert.Equal(mergeResult.Commit, repo.Branches["refs/remotes/origin/master"].Tip);
Assert.Equal(repo.Head.Tip, repo.Branches["refs/remotes/origin/master"].Tip);
}
else
{
Assert.Equal(mergeResult.Status, MergeStatus.NonFastForward);
}
}
}
