/// <summary> /// Get's the latest and greatest from remote /// </summary> /// <param name="gitUser"> /// The Git User. /// </param> /// <param name="gitPass"> /// The Git Pass. /// </param> /// <returns> /// A boolean that signals success /// </returns> public bool Fetch(string gitUser, string gitPass) { log.Debug("Fetch on remote repo"); if (File.Exists(ExternalGitPath)) { string GitOutput = ExecuteGitCommand("pull"); bool result = Regex.IsMatch(GitOutput, "\\bfatal\\b", RegexOptions.IgnoreCase); if (result == true) { return false; } } else { try { var signature = new Signature( "pass4win", "*****@*****.**", new DateTimeOffset(2011, 06, 16, 10, 58, 27, TimeSpan.FromHours(2))); var fetchOptions = new FetchOptions { CredentialsProvider = (url, user, cred) => new UsernamePasswordCredentials { Username = gitUser, Password = gitPass } }; var mergeOptions = new MergeOptions(); var pullOptions = new PullOptions { FetchOptions = fetchOptions, MergeOptions = mergeOptions }; this.gitRepo.Network.Pull(signature, pullOptions); } catch (Exception message) { log.Debug(message); return false; } } return true; }
public void Fetch(string remoteName) { using var repository = new LibGit2Sharp.Repository(Module.WorkingDir); var options = new LibGit2Sharp.FetchOptions(); Commands.Fetch(repository, remoteName, Array.Empty <string>(), options, null); }
public static void NormalizeGitDirectory(string gitDirectory) { using (var repo = new Repository(gitDirectory)) { var remote = EnsureOnlyOneRemoteIsDefined(repo); Log.Info("Fetching from remote '{0}' using the following refspecs: {1}.", remote.Name, string.Join(", ", remote.FetchRefSpecs.Select(r => r.Specification))); var fetchOptions = new FetchOptions(); repo.Network.Fetch(remote, fetchOptions); CreateMissingLocalBranchesFromRemoteTrackingOnes(repo, remote.Name); if (!repo.Info.IsHeadDetached) { Log.Info("HEAD points at branch '{0}'.", repo.Refs.Head.TargetIdentifier); return; } Log.Info("HEAD is detached and points at commit '{0}'.", repo.Refs.Head.TargetIdentifier); CreateFakeBranchPointingAtThePullRequestTip(repo); } }
public void CloneRepo() { var scd = BuildSelfCleaningDirectory(); CloneOptions options = new CloneOptions(); var credentials = new UsernamePasswordCredentials(); credentials.Username = Constants.Identity.Name; credentials.Password = "******"; options.CredentialsProvider += (url, fromUrl, types) => credentials; string clonedRepoPath = Repository.Clone(testUrl, scd.DirectoryPath, options); string file = Path.Combine(scd.DirectoryPath, "testpush.txt"); var rbg = new RandomBufferGenerator(30000); using (var repo = new Repository(clonedRepoPath)) { for (int i = 0; i < 1; i++) { var network = repo.Network.Remotes.First(); FetchOptions fetchOptions = new FetchOptions(); fetchOptions.CredentialsProvider += (url, fromUrl, types) => credentials; repo.Fetch(network.Name, fetchOptions); File.WriteAllBytes(file, rbg.GenerateBufferFromSeed(30000)); repo.Stage(file); Signature author = Constants.Signature; Commit commit = repo.Commit($"Here's a commit {i + 1} i made!", author, author); PushOptions pushOptions = new PushOptions(); pushOptions.CredentialsProvider += (url, fromUrl, types) => credentials; repo.Network.Push(repo.Branches["master"], pushOptions); } } }
public Task<List<ISourceItem>> FetchAllFiles(BuildConfig config) { string gitFolder = config.BuildFolder + "\\git"; //// temporary hack... //// git-pull does not work //if (Directory.Exists(gitFolder)) { // Directory.Delete(gitFolder, true); //} if (!Directory.Exists(gitFolder)) { Directory.CreateDirectory(gitFolder); Console.WriteLine("Cloning repository " + config.SourceUrl); CloneOptions clone = new CloneOptions(); clone.CredentialsProvider = CredentialsHandler; var rep = Repository.Clone(config.SourceUrl, gitFolder, clone); Console.WriteLine("Repository clone successful"); } else { Console.WriteLine("Fetching remote Repository"); var rep = new Repository(gitFolder); FetchOptions options = new FetchOptions(); options.CredentialsProvider = CredentialsHandler; Remote remote = rep.Network.Remotes["origin"]; //Commands.Fetch(rep,remote.Name,) //rep.Fetch(remote.Name, options); var master = rep.Branches["master"]; Commands.Pull(rep, new Signature("IISCI", "*****@*****.**", DateTime.Now), new PullOptions() { FetchOptions = options, MergeOptions = new MergeOptions() { MergeFileFavor = MergeFileFavor.Theirs, CommitOnSuccess = true } }); Console.WriteLine("Fetch successful"); } List<ISourceItem> files = new List<ISourceItem>(); EnumerateFiles( new DirectoryInfo(gitFolder), files, "" ); Parallel.ForEach(files, file => { var md5 = System.Security.Cryptography.MD5.Create(); ((GitSourceItem)file).Version = Convert.ToBase64String(md5.ComputeHash(File.ReadAllBytes(file.Url))); }); return Task.FromResult(files); }
internal RemoteCallbacks(FetchOptions fetchOptions) { Ensure.ArgumentNotNull(fetchOptions, "fetchOptions"); Progress = fetchOptions.OnProgress; DownloadTransferProgress = fetchOptions.OnTransferProgress; UpdateTips = fetchOptions.OnUpdateTips; Credentials = fetchOptions.Credentials; }
/// <summary> /// Fetch from the <see cref="Remote"/>. /// </summary> /// <param name="remote">The remote to fetch</param> /// <param name="options"><see cref="FetchOptions"/> controlling fetch behavior</param> public virtual void Fetch(Remote remote, FetchOptions options = null) { Ensure.ArgumentNotNull(remote, "remote"); using (RemoteSafeHandle remoteHandle = Proxy.git_remote_load(repository.Handle, remote.Name, true)) { DoFetch(remoteHandle, options); } }
/// <summary> /// Fetch from the <see cref="Remote"/>. /// </summary> /// <param name="remote">The remote to fetch</param> /// <param name="options"><see cref="FetchOptions"/> controlling fetch behavior</param> /// <param name="signature">Identity for use when updating the reflog.</param> /// <param name="logMessage">Message to use when updating the reflog.</param> public virtual void Fetch(Remote remote, FetchOptions options = null, Signature signature = null, string logMessage = null) { Ensure.ArgumentNotNull(remote, "remote"); using (RemoteSafeHandle remoteHandle = Proxy.git_remote_load(repository.Handle, remote.Name, true)) { DoFetch(remoteHandle, options, signature.OrDefault(repository.Config), logMessage); } }
public void Fetch(string remoteName) { var fetchOptions = new FetchOptions() { CredentialsProvider = (url, usernameFromUrl, types) => new UsernamePasswordCredentials() { Username = UserName, Password = Password } }; Repository.Fetch(remoteName, fetchOptions); }
static FetchOptions BuildFetchOptions(string username, string password) { var fetchOptions = new FetchOptions(); if (!string.IsNullOrEmpty(username)) { fetchOptions.Credentials = new UsernamePasswordCredentials { Username = username, Password = password }; } return fetchOptions; }
public static FetchOptions ToFetchOptions(this AuthenticationInfo authenticationInfo) { var fetchOptions = new FetchOptions(); if (authenticationInfo != null) { if (!string.IsNullOrEmpty(authenticationInfo.Username)) { fetchOptions.CredentialsProvider = (url, user, types) => new UsernamePasswordCredentials { Username = authenticationInfo.Username, Password = authenticationInfo.Password }; } } return fetchOptions; }
/// <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)) { 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 = new GitFetchOptions { RemoteCallbacks = gitCallbacks, 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; } fetchOptions.ProxyOptions = new GitProxyOptions { Version = 1 }; Proxy.git_remote_fetch(remoteHandle, refspecs, fetchOptions, logMessage); } }
private static void DoFetch(FetchOptions options, RemoteSafeHandle remoteHandle, string logMessage, IEnumerable <string> refspecs) { Debug.Assert(remoteHandle != null && !remoteHandle.IsClosed && !remoteHandle.IsInvalid); options = options ?? new FetchOptions(); 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 = new GitFetchOptions { RemoteCallbacks = gitCallbacks, 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; } Proxy.git_remote_fetch(remoteHandle, refspecs, fetchOptions, logMessage); }
public static void BUYLCloneOrUpdateRepository() { if (!CheckForContentRepositoryDirectory()) { //prg.ShowDialog(); Directory.CreateDirectory(pathToLocalContentRepository); CloneOptions op = new CloneOptions(); Repository.Clone(urlContentRepository, pathToLocalContentRepository, op); //prg.Close(); } else { using (var repo = new Repository(pathToLocalContentRepository)) { Remote remote = repo.Network.Remotes["origin"]; FetchOptions op = new FetchOptions(); repo.Network.Fetch(remote); } } }
static void DoFetch(RemoteSafeHandle remoteHandle, FetchOptions options) { if (options == null) { options = new FetchOptions(); } if (options.TagFetchMode.HasValue) { Proxy.git_remote_set_autotag(remoteHandle, options.TagFetchMode.Value); } 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. Proxy.git_remote_set_callbacks(remoteHandle, ref gitCallbacks); try { Proxy.git_remote_connect(remoteHandle, GitDirection.Fetch); Proxy.git_remote_download(remoteHandle); Proxy.git_remote_update_tips(remoteHandle); } finally { Proxy.git_remote_disconnect(remoteHandle); } }
static void DoFetch(RemoteSafeHandle remoteHandle, FetchOptions options, Signature signature, string logMessage) { if (options == null) { options = new FetchOptions(); } if (options.TagFetchMode.HasValue) { Proxy.git_remote_set_autotag(remoteHandle, options.TagFetchMode.Value); } 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. Proxy.git_remote_set_callbacks(remoteHandle, ref gitCallbacks); Proxy.git_remote_fetch(remoteHandle, signature, logMessage); }
/// <summary> /// Fetch from the <see cref="Remote"/>, using custom refspecs. /// </summary> /// <param name="remote">The remote to fetch</param> /// <param name="refspecs">Refspecs to use, replacing the remote's fetch refspecs</param> /// <param name="options"><see cref="FetchOptions"/> controlling fetch behavior</param> public virtual void Fetch(Remote remote, IEnumerable<string> refspecs, FetchOptions options = null) { Ensure.ArgumentNotNull(remote, "remote"); Ensure.ArgumentNotNull(refspecs, "refspecs"); using (RemoteSafeHandle remoteHandle = Proxy.git_remote_load(repository.Handle, remote.Name, true)) { Proxy.git_remote_set_fetch_refspecs(remoteHandle, refspecs); DoFetch(remoteHandle, options); } }
/// <summary> /// Fetch from a url with a set of fetch refspecs /// </summary> /// <param name="url">The url to fetch from</param> /// <param name="refspecs">The list of resfpecs to use</param> /// <param name="options"><see cref="FetchOptions"/> controlling fetch behavior</param> /// <param name="signature">Identity for use when updating the reflog.</param> /// <param name="logMessage">Message to use when updating the reflog.</param> public virtual void Fetch( string url, IEnumerable<string> refspecs, FetchOptions options = null, Signature signature = null, string logMessage = null) { Ensure.ArgumentNotNull(url, "url"); Ensure.ArgumentNotNull(refspecs, "refspecs"); using (RemoteSafeHandle remoteHandle = Proxy.git_remote_create_anonymous(repository.Handle, url, null)) { Proxy.git_remote_set_fetch_refspecs(remoteHandle, refspecs); DoFetch(remoteHandle, options, signature.OrDefault(repository.Config), logMessage); } }
/// <summary> /// Fetch from the <see cref="Remote"/>, using custom refspecs. /// </summary> /// <param name="remote">The remote to fetch</param> /// <param name="refspecs">Refspecs to use, replacing the remote's fetch refspecs</param> /// <param name="options"><see cref="FetchOptions"/> controlling fetch behavior</param> public virtual void Fetch(Remote remote, IEnumerable <string> refspecs, FetchOptions options) { Fetch(remote, refspecs, options, null); }
/// <summary> /// Fetch from a url with a set of fetch refspecs /// </summary> /// <param name="url">The url to fetch from</param> /// <param name="refspecs">The list of resfpecs to use</param> /// <param name="options"><see cref="FetchOptions"/> controlling fetch behavior</param> public virtual void Fetch(string url, IEnumerable <string> refspecs, FetchOptions options) { Fetch(url, refspecs, options, null); }
public GitClient(IGitHubCredentialProvider credentialProvider) { pushOptions = new PushOptions { CredentialsProvider = credentialProvider.HandleCredentials }; fetchOptions = new FetchOptions { CredentialsProvider = credentialProvider.HandleCredentials }; }
/// <summary> /// Fetch from the <see cref="Remote"/>. /// </summary> /// <param name="remote">The remote to fetch</param> /// <param name="options"><see cref="FetchOptions"/> controlling fetch behavior</param> public virtual void Fetch(Remote remote, FetchOptions options) { Fetch(remote, options, null); }
public virtual void Fetch(Remote remote, IEnumerable <string> refspecs, FetchOptions options) { Commands.Fetch(repository, remote.Name, refspecs, options, null); }
public virtual void Fetch(Remote remote, FetchOptions options, string logMessage) { Commands.Fetch(repository, remote.Name, new string[0], options, logMessage); }
// private helper methods. private void NormalizeGitDirectory() { var remote = EnsureSingleRemoteIsDefined(); EnsureRepoHasRefSpecs(remote); Log.WriteLine("Fetching from remote '{0}' using the following refspecs: {1}.", remote.Name, string.Join(", ", remote.FetchRefSpecs.Select(r => r.Specification))); var fetchOptions = new FetchOptions(); fetchOptions.CredentialsProvider = (url, user, types) => credentials; Repository.Network.Fetch(remote, fetchOptions); CreateMissingLocalBranchesFromRemoteTrackingOnes(remote.Name); var headSha = Repository.Refs.Head.TargetIdentifier; if (!Repository.Info.IsHeadDetached) { Log.WriteLine("HEAD points at branch '{0}'.", headSha); return; } Log.WriteLine("HEAD is detached and points at commit '{0}'.", headSha); // In order to decide whether a fake branch is required or not, first check to see if any local branches have the same commit SHA of the head SHA. // If they do, go ahead and checkout that branch // If no, go ahead and check out a new branch, using the known commit SHA as the pointer var localBranchesWhereCommitShaIsHead = Repository.Branches.Where(b => !b.IsRemote && b.Tip.Sha == headSha).ToList(); if (localBranchesWhereCommitShaIsHead.Count > 1) { var names = string.Join(", ", localBranchesWhereCommitShaIsHead.Select(r => r.CanonicalName)); var message = string.Format("Found more than one local branch pointing at the commit '{0}'. Unable to determine which one to use ({1}).", headSha, names); throw new InvalidOperationException(message); } if (localBranchesWhereCommitShaIsHead.Count == 0) { Log.WriteLine("No local branch pointing at the commit '{0}'. Fake branch needs to be created.", headSha); CreateFakeBranchPointingAtThePullRequestTip(); } else { Log.WriteLine("Checking out local branch 'refs/heads/{0}'.", localBranchesWhereCommitShaIsHead[0].Name); Repository.Branches[localBranchesWhereCommitShaIsHead[0].Name].Checkout(); } }
/// <summary> /// Fetch from the <see cref="Remote"/>, using custom refspecs. /// </summary> /// <param name="remote">The remote to fetch</param> /// <param name="refspecs">Refspecs to use, replacing the remote's fetch refspecs</param> /// <param name="options"><see cref="FetchOptions"/> controlling fetch behavior</param> /// <param name="signature">Identity for use when updating the reflog.</param> /// <param name="logMessage">Message to use when updating the reflog.</param> public virtual void Fetch(Remote remote, IEnumerable<string> refspecs, FetchOptions options = null, Signature signature = null, string logMessage = null) { Ensure.ArgumentNotNull(remote, "remote"); Ensure.ArgumentNotNull(refspecs, "refspecs"); using (RemoteSafeHandle remoteHandle = Proxy.git_remote_lookup(repository.Handle, remote.Name, true)) { Proxy.git_remote_set_fetch_refspecs(remoteHandle, refspecs); DoFetch(remoteHandle, options, signature.OrDefault(repository.Config), logMessage); } }
public frmMain() { InitializeComponent(); // Checking for appsettings // Do we have a valid password store if (Properties.Settings.Default.PassDirectory == "firstrun") { if (folderBrowserDialog1.ShowDialog() == DialogResult.OK) { Properties.Settings.Default.PassDirectory = folderBrowserDialog1.SelectedPath; } else { MessageBox.Show("We need a place to store stuff. Restart the program and try again.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); System.Environment.Exit(1); } } // GPG exe location if (Properties.Settings.Default.GPGEXE == "firstrun") { if (openFileDialog1.ShowDialog() == DialogResult.OK) { Properties.Settings.Default.GPGEXE = openFileDialog1.FileName; } else { MessageBox.Show("We really need GPG2.exe. Restart the program and try again.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); System.Environment.Exit(1); } } //checking git status if (!Repository.IsValid(Properties.Settings.Default.PassDirectory)) { string value = ""; // Do we have a remote if (InputBox.Show("Enter the remote git repo or blank for no remote", "Remote Git (HTTPS):", ref value) == DialogResult.OK) { Properties.Settings.Default.GitRemote = value; if (Properties.Settings.Default.GitRemote != "") { // Get username and password value = ""; if (InputBox.Show("Username", "Remote Username:"******""; if (InputBox.Show("Password", "Remote Password:"******"Couldn't connect to remote git repository. Restart the program and try again.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); System.Environment.Exit(1); } // save encrypted version of user and pass for git Properties.Settings.Default.GitUser = EncryptConfig(GitUsername, "pass4win"); Properties.Settings.Default.GitPass = EncryptConfig(GitPassword, "pass4win"); } } } } // Checking if the remote is cloned succesfull if (!Repository.IsValid(Properties.Settings.Default.PassDirectory)) { // creating new Git Repository.Init(Properties.Settings.Default.PassDirectory); Properties.Settings.Default.GitUser = EncryptConfig("RandomGarbage", "pass4win"); Properties.Settings.Default.GitPass = EncryptConfig("RandomGarbage", "pass4win"); } } else { // so we have a repository let's load the user/pass if (Properties.Settings.Default.GitUser != "") { GitUsername = DecryptConfig(Properties.Settings.Default.GitUser, "pass4win"); GitPassword = DecryptConfig(Properties.Settings.Default.GitPass, "pass4win"); } else { string value = ""; if (InputBox.Show("Username", "Remote Username:"******""; if (InputBox.Show("Password", "Remote Password:"******"We really need a username. Restart the program and try again.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); System.Environment.Exit(1); } if (GitPassword == null) { MessageBox.Show("We really need a password. Restart the program and try again.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); System.Environment.Exit(1); } Properties.Settings.Default.GitUser = EncryptConfig(GitUsername, "pass4win"); Properties.Settings.Default.GitPass = EncryptConfig(GitPassword, "pass4win"); } // Check if we have the latest using (var repo = new Repository(Properties.Settings.Default.PassDirectory)) { Signature Signature = new 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 = GitUsername, Password = GitPassword }; MergeOptions mergeOptions = new MergeOptions(); PullOptions pullOptions = new PullOptions(); pullOptions.FetchOptions = fetchOptions; pullOptions.MergeOptions = mergeOptions; MergeResult mergeResult = repo.Network.Pull(Signature, pullOptions); } } // Init GPG if needed string gpgfile = Properties.Settings.Default.PassDirectory; gpgfile += "\\.gpg-id"; // Check if we need to init the directory if (!File.Exists(gpgfile)) { Directory.CreateDirectory(Path.GetDirectoryName(gpgfile)); KeySelect newKeySelect = new KeySelect(); if (newKeySelect.ShowDialog() == DialogResult.OK) { using (StreamWriter w = new StreamWriter(gpgfile)) { w.Write(newKeySelect.gpgkey); } using (var repo = new Repository(Properties.Settings.Default.PassDirectory)) { repo.Stage(gpgfile); repo.Commit("gpgid added", new Signature("pass4win", "pass4win", System.DateTimeOffset.Now), new Signature("pass4win", "pass4win", System.DateTimeOffset.Now)); } } else { MessageBox.Show("Need key...... Restart the program and try again.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); System.Environment.Exit(1); } } // Setting the exe location for the GPG Dll GpgInterface.ExePath = Properties.Settings.Default.GPGEXE; // saving settings Properties.Settings.Default.Save(); // Setting up datagrid dt.Columns.Add("colPath", typeof(string)); dt.Columns.Add("colText", typeof(string)); ListDirectory(new DirectoryInfo(Properties.Settings.Default.PassDirectory), ""); dataPass.DataSource = dt.DefaultView; dataPass.Columns[0].Visible=false; }
/// <summary> /// Fetch from a url with a set of fetch refspecs /// </summary> /// <param name="url">The url to fetch from</param> /// <param name="refspecs">The list of resfpecs to use</param> /// <param name="options"><see cref="FetchOptions"/> controlling fetch behavior</param> public virtual void Fetch( string url, IEnumerable<string> refspecs, FetchOptions options = null) { Ensure.ArgumentNotNull(url, "url"); Ensure.ArgumentNotNull(refspecs, "refspecs"); using (RemoteSafeHandle remoteHandle = Proxy.git_remote_create_inmemory(repository.Handle, null, url)) { Proxy.git_remote_set_fetch_refspecs(remoteHandle, refspecs); DoFetch(remoteHandle, options); } }
/// <summary>Fetches the latest from the remote, and checks out the remote branch (ie. does not attempt to merge).</summary> /// <param name="remoteName">'origin' by default.</param> /// <param name="branch">'master' by default</param> /// <param name="username">null by default</param> /// <param name="password">null by default</param> public void FetchLatest(string remoteName="origin", string branch = "master", string username=null, string password=null) { if (HasChanges) { // uh oh ... something has gone awry. We should reset before attempting to fetch changes Reset(); } var remote = repository.Network.Remotes[remoteName]; var options = new FetchOptions() { TagFetchMode = TagFetchMode.None }; if (!string.IsNullOrWhiteSpace(username)) { var creds = new UsernamePasswordCredentials { Username = username, Password = password }; options.CredentialsProvider = (_url, _user, _cred) => creds; repository.Network.Fetch(remote, options: options); } else { repository.Network.Fetch(remote, options:options); } var remoteBranch = repository.Branches.Single(b => b.Name == string.Format("{0}/{1}", remoteName, branch)); repository.Checkout(remoteBranch); }
public virtual void Fetch(Remote remote, IEnumerable<string> refspecs, FetchOptions options) { Commands.Fetch(repository, remote.Name, refspecs, options, null); }
public ModificationViewModel(IScreen screen, ICredentialStore store, IObservable<RepositoryModel> repository) { this.disposables = new List<IDisposable>(); this.fileSystem = new FileSystemObservable(); this.refreshCommand = ReactiveCommand.Create(); var samples = Observable.Interval(TimeSpan.FromSeconds(60)) .Select(i => new object()) .Merge(this.refreshCommand.Select(i => new object())) .Merge(repository.Delay(TimeSpan.FromSeconds(1)).Select(i => new object())); var distinctRepository = repository.DistinctUntilChanged(r => r.Path); distinctRepository.MapToMember(this, vm => vm.currentRepositoryModel); distinctRepository.Select(_ => _.Path).MapToMember(this, vm => vm.fileSystem.Path); var activeBranch = repository .SelectMany(rm => rm.WhenAny(vm => vm.CurrentBranch, change => change.GetValue())) .SampleEx(samples); activeBranch .ObserveOn(System.Reactive.Concurrency.TaskPoolScheduler.Default) .SubscribeOn(System.Reactive.Concurrency.TaskPoolScheduler.Default) .Subscribe(branch => { if (branch.IsTracking) { //Fetch repository status. var currentRemote = branch.Remote; var refSpecs = this.currentRepositoryModel.Repository.Network.Remotes.Select(r => new { FetchRefSpecs = r.FetchRefSpecs .Where(frs => frs.Direction == RefSpecDirection.Fetch) .Select(frs => frs.Specification), Remote = r } ); var credentialProvider = new CredentialProvider(screen, store); foreach (var item in refSpecs) { FetchOptions options = new FetchOptions() { CredentialsProvider = credentialProvider.CredentialHandler }; try { this.currentRepositoryModel.Repository.Network.Fetch(item.Remote, item.FetchRefSpecs, options); } catch { } } } }); activeBranch .Select(b => b.TrackingDetails).Subscribe(_ => { this.Ahead = (_.AheadBy.HasValue) ? _.AheadBy.Value : 0; this.Behind = (_.BehindBy.HasValue) ? _.BehindBy.Value : 0; }); var activeBranchFileStatus = activeBranch.AnonymousMerge(fileSystem, 0) .AnonymousMerge(this.refreshCommand.AsObservable(), 0) .Throttle(TimeSpan.FromSeconds(5)) .Select(branch => { var opts = new LibGit2Sharp.StatusOptions(); opts.DetectRenamesInIndex = true; opts.DetectRenamesInWorkDir = true; opts.Show = StatusShowOption.IndexAndWorkDir; return this.currentRepositoryModel.Repository.RetrieveStatus(opts); }); this.files = new DeltaViewModel<int> ( activeBranchFileStatus.Select(s => s.Modified.Count()), activeBranchFileStatus.Select(s => s.Added.Count() + s.Untracked.Count()), activeBranchFileStatus.Select(s => s.Removed.Count()) ); ConfigureLineChanges(activeBranch); ConfigureCommitCommands(); this.thresholds = new Thresholds( this.ObservableForProperty(vm => vm.Behind, false, false).Select(change => change.GetValue()), this.ObservableForProperty(vm => vm.Ahead).Select(change => change.GetValue()), this.ObservableForProperty(vm => vm.LinesAdded).Select(change => change.GetValue()), this.ObservableForProperty(vm => vm.LinesRemoved).Select(change => change.GetValue()), this.Files.ObservableForProperty(vm => vm.Added).Select(change => change.GetValue()), this.Files.ObservableForProperty(vm => vm.Removed).Select(change => change.GetValue())); }
public virtual void Fetch(Remote remote, IEnumerable<string> refspecs, FetchOptions options, string logMessage) { Ensure.ArgumentNotNull(remote, "remote"); Ensure.ArgumentNotNull(refspecs, "refspecs"); Commands.Fetch(repository, remote.Name, refspecs, options, logMessage); }
/// <summary> /// Get's the latest and greatest from remote /// </summary> /// <returns></returns> public bool GitFetch() { if (Cfg["UseGitRemote"] == true && this.gitRepoOffline == false) { toolStripOffline.Visible = false; using (var repo = new Repository(Cfg["PassDirectory"])) { var signature = new Signature("pass4win", "*****@*****.**", new DateTimeOffset(2011, 06, 16, 10, 58, 27, TimeSpan.FromHours(2))); var fetchOptions = new FetchOptions { CredentialsProvider = (url, user, cred) => new UsernamePasswordCredentials { Username = Cfg["GitUser"], Password = DecryptConfig(Cfg["GitPass"], "pass4win") } }; var mergeOptions = new MergeOptions(); var pullOptions = new PullOptions { FetchOptions = fetchOptions, MergeOptions = mergeOptions }; try { repo.Network.Pull(signature, pullOptions); } catch (Exception) { return false; } } } return true; }
/// <summary> /// Fetch from a url with a set of fetch refspecs /// </summary> /// <param name="url">The url to fetch from</param> /// <param name="refspecs">The list of resfpecs to use</param> /// <param name="options"><see cref="FetchOptions"/> controlling fetch behavior</param> public virtual void Fetch(string url, IEnumerable<string> refspecs, FetchOptions options) { Fetch(url, refspecs, options, null); }
/// <summary> /// Fetch from the <see cref="Remote"/>. /// </summary> /// <param name="remote">The remote to fetch</param> /// <param name="options"><see cref="FetchOptions"/> controlling fetch behavior</param> /// <param name="logMessage">Message to use when updating the reflog.</param> public virtual void Fetch(Remote remote, FetchOptions options, string logMessage) { Ensure.ArgumentNotNull(remote, "remote"); DoFetch(repository.Handle, remote, options, logMessage, new string[0]); }
/// <summary> /// Fetch from a url with a set of fetch refspecs /// </summary> /// <param name="url">The url to fetch from</param> /// <param name="refspecs">The list of resfpecs to use</param> /// <param name="options"><see cref="FetchOptions"/> controlling fetch behavior</param> /// <param name="logMessage">Message to use when updating the reflog.</param> public virtual void Fetch( string url, IEnumerable<string> refspecs, FetchOptions options, string logMessage) { Ensure.ArgumentNotNull(url, "url"); Ensure.ArgumentNotNull(refspecs, "refspecs"); Commands.Fetch(repository, url, refspecs, options, logMessage); }
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 }; }
public virtual void Fetch(Remote remote, FetchOptions options) { Commands.Fetch(repository, remote.Name, new string[0], options, null); }
/// <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)) { 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 = new GitFetchOptions { RemoteCallbacks = gitCallbacks, 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; } fetchOptions.ProxyOptions = new GitProxyOptions { Version = 1 }; Proxy.git_remote_fetch(remoteHandle, refspecs, fetchOptions, logMessage); } }