/// <inheritdoc />
        public static IObservable<IObservableRepository> Clone(
            string sourceUrl,
            string workingDirectory,
            IObserver<Tuple<string, int>> observer,
            CredentialsHandler credentials = null)
        {
            var isCancelled = false;
            var options = new CloneOptions
            {
                Checkout = true,
                CredentialsProvider = credentials,
                OnTransferProgress = progress =>
                {
                    // TODO: how should we signal for the "indexing objects" events
                    var p = (100 * progress.ReceivedObjects) / progress.TotalObjects;
                    var receivingMessage = String.Format("Receiving objects:  {0}% ({1}/{2})", p, progress.ReceivedObjects, progress.TotalObjects);
                    observer.OnNext(Tuple.Create(receivingMessage, p));
                    return !isCancelled;
                },
                IsBare = false,
                OnCheckoutProgress = ProgressFactory.CreateHandlerWithoutMessages(observer)
            };

            var directoryInfo = new DirectoryInfo(workingDirectory);
            var initialMessage = String.Format("Cloning into '{0}'...", directoryInfo.Name);
            observer.OnNext(Tuple.Create(initialMessage, 0));

            return Observable.Create<ObservableRepository>(subj =>
            {
                var sub = Observable.Start(() =>
                {
                    var directory = Repository.Clone(sourceUrl, workingDirectory, options);

                    observer.OnNext(Tuple.Create("clone completed", 100));
                    observer.OnCompleted();

                    return new ObservableRepository(directory, credentials);
                }, Scheduler.Default).Subscribe(subj);

                return new CompositeDisposable(
                    sub,
                    Disposable.Create(() =>
                    {
                        isCancelled = true;
                        observer.OnCompleted();
                    }));
            });
        }
Пример #2
0
 public void Fetch(string remoteName, CredentialsHandler credentials, IEventStream?eventStream = null, bool prune = false)
 {
     if (repository.Network.Remotes.FirstOrDefault(x => x.Name == remoteName) is Remote remote)
     {
         Fetch(remote, credentials, eventStream, prune);
     }
 }
        public GitProvider(ILogger <GitProvider> logger, GitProviderOptions providerOptions)
        {
            _logger          = logger;
            _providerOptions = providerOptions;

            if (string.IsNullOrWhiteSpace(_providerOptions.LocalPath))
            {
                throw new ArgumentNullException(nameof(_providerOptions.LocalPath), $"{nameof(_providerOptions.LocalPath)} cannot be NULL or empty.");
            }

            if (string.IsNullOrWhiteSpace(_providerOptions.RepositoryUrl))
            {
                throw new ArgumentNullException(nameof(_providerOptions.RepositoryUrl), $"{nameof(_providerOptions.RepositoryUrl)} cannot be NULL or empty.");
            }

            if (string.IsNullOrWhiteSpace(_providerOptions.Username))
            {
                throw new ArgumentNullException(nameof(_providerOptions.Username), $"{nameof(_providerOptions.Username)} cannot be NULL or empty.");
            }

            if (string.IsNullOrWhiteSpace(_providerOptions.Password))
            {
                throw new ArgumentNullException(nameof(_providerOptions.Password), $"{nameof(_providerOptions.Password)} cannot be NULL or empty.");
            }

            _credentialsHandler = (url, user, cred) => new UsernamePasswordCredentials
            {
                Username = _providerOptions.Username,
                Password = _providerOptions.Password
            };
        }
Пример #4
0
        /// <summary>
        /// List references in a remote repository.
        /// <para>
        /// When the remote tips are ahead of the local ones, the retrieved
        /// <see cref="DirectReference"/>s may point to non existing
        /// <see cref="GitObject"/>s in the local repository. In that
        /// case, <see cref="DirectReference.Target"/> will return <c>null</c>.
        /// </para>
        /// </summary>
        /// <param name="url">The url to list from.</param>
        /// <param name="credentialsProvider">The <see cref="Func{Credentials}"/> used to connect to remote repository.</param>
        /// <returns>The references in the remote repository.</returns>
        public virtual IEnumerable <Reference> ListReferences(string url, CredentialsHandler credentialsProvider)
        {
            Ensure.ArgumentNotNull(url, "url");
            Ensure.ArgumentNotNull(credentialsProvider, "credentialsProvider");

            return(ListReferencesInternal(url, credentialsProvider));
        }
Пример #5
0
        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 + @"\", ""));
                }
            }
        }
Пример #6
0
        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
            };
        }
Пример #7
0
        static CredentialsHandler CreateCredentialsHandler(IRepository repo, string remoteName)
        {
            var remote    = repo.Network.Remotes[remoteName];
            var remoteUri = new Uri(remote.Url);

            var secrets = new SecretStore("git");
            var auth    = new BasicAuthentication(secrets);

            var targetUrl = remoteUri.GetLeftPart(UriPartial.Authority);
            var creds     = auth.GetCredentials(new TargetUri(targetUrl));

            if (creds == null)
            {
                return(null);
            }

            CredentialsHandler credentialsHandler =
                (url, user, cred) => new UsernamePasswordCredentials
            {
                Username = creds.Username,
                Password = creds.Password
            };

            return(credentialsHandler);
        }
Пример #8
0
        /// <summary>
        /// List references in a <see cref="Remote"/> repository.
        /// <para>
        /// When the remote tips are ahead of the local ones, the retrieved
        /// <see cref="DirectReference"/>s may point to non existing
        /// <see cref="GitObject"/>s in the local repository. In that
        /// case, <see cref="DirectReference.Target"/> will return <c>null</c>.
        /// </para>
        /// </summary>
        /// <param name="remote">The <see cref="Remote"/> to list from.</param>
        /// <param name="credentialsProvider">The <see cref="Func{Credentials}"/> used to connect to remote repository.</param>
        /// <returns>The references in the <see cref="Remote"/> repository.</returns>
        public virtual IEnumerable <Reference> ListReferences(Remote remote, CredentialsHandler credentialsProvider)
        {
            Ensure.ArgumentNotNull(remote, "remote");
            Ensure.ArgumentNotNull(credentialsProvider, "credentialsProvider");

            return(ListReferencesInternal(remote.Url, credentialsProvider));
        }
Пример #9
0
 public void Pull(string branchName, CredentialsHandler GitCredentialsHandler)
 {
     LibGit2Sharp.PullOptions pullOptions = new LibGit2Sharp.PullOptions();
     pullOptions.FetchOptions = new FetchOptions();
     pullOptions.FetchOptions.CredentialsProvider = GitCredentialsHandler;
     LibGit2Sharp.Commands.Pull(repository, new LibGit2Sharp.Signature(UserName, Email, new DateTimeOffset(DateTime.Now)), pullOptions);
 }
Пример #10
0
        public override IRepository Clone(string remotePathOrUrl, string workingDirectory, SecureCredentials credentials = null)
        {
            try
            {
                var name = GetProjectNameFromDirectory(remotePathOrUrl);

                if (credentials == null)
                {
                    LibGit2Sharp.Repository.Clone(remotePathOrUrl, workingDirectory);
                }
                else
                {
                    var credentialsHandler = new CredentialsHandler((url, usernameFromUrl, types) => new SecureUsernamePasswordCredentials
                    {
                        Username = credentials.Username,
                        Password = credentials.Password
                    });

                    var options = new CloneOptions {
                        CredentialsProvider = credentialsHandler
                    };
                    LibGit2Sharp.Repository.Clone(remotePathOrUrl, workingDirectory, options);
                }

                return(new Repository(name, workingDirectory, remotePathOrUrl));
            }
            catch (LibGit2SharpException ex)
            {
                throw new SourceControlException(SourceControlText.GitRepoNotCloned, ex);
            }
        }
        public async Task GetProgressFromASyncOperation()
        {
            CredentialsHandler credentials = (url, usernameFromUrl, types) =>
                                             new UsernamePasswordCredentials
            {
                Username = "******",
                Password = "******"
            };

            var repository = new ObservableRepository(
                @"C:\Users\brendanforster\Documents\GìtHūb\testing-pushspecs",
                credentials);

            Func <int, int> translate = x => x / 3;

            var pullObserver = new ReplaySubject <Tuple <string, int> >();
            var pushObserver = new ReplaySubject <Tuple <string, int> >();

            var pullResult = await repository.Pull(pullObserver);

            Assert.NotEqual(MergeStatus.Conflicts, pullResult.Status);

            await repository.Push(pushObserver);

            var list = await pullObserver.Select(x => translate(x.Item2) * 2)
                       .Concat(pushObserver.Select(x => 67 + translate(x.Item2)))
                       .ToList();

            Assert.NotEmpty(list);
            Assert.Equal(100, list.Last());
        }
Пример #12
0
 public PushCommand(IEventStream eventStream, MainThread mainThread, IGitRepository repository, CredentialsHandler credentialsProvider, SyncView view)
 {
     this.eventStream         = eventStream;
     this.mainThread          = mainThread;
     this.repository          = repository;
     this.credentialsProvider = credentialsProvider;
     this.view = view;
 }
Пример #13
0
 /// <summary>
 /// Build clone options for an empty .git directory with only the used parameter
 /// </summary>
 /// <param name="credentialsHandler"></param>
 /// <returns></returns>
 private static CloneOptions GetCloneOptions(CredentialsHandler credentialsHandler)
 {
     return(new CloneOptions
     {
         IsBare = true,
         CredentialsProvider = credentialsHandler
     });
 }
Пример #14
0
        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);
        }
Пример #15
0
        public GitProvider(VBProject project, IRepository repository, string userName, string passWord, ICodePaneWrapperFactory wrapperFactory)
            : this(project, repository, wrapperFactory)
        {
            _credentials = new UsernamePasswordCredentials()
            {
                Username = userName,
                Password = passWord
            };

            _credentialsHandler = (url, user, cred) => _credentials;
        }
Пример #16
0
        private CredentialsHandler GetSourceCredentialsHandler()
        {
            var credentials = new UsernamePasswordCredentials()
            {
                Username = SourceControlUser,
                Password = SourceControlPass,
            };
            CredentialsHandler credentialHandler = (_url, _user, _cred) => credentials;

            return(credentialHandler);
        }
Пример #17
0
        public GitProvider(VBProject project, IRepository repository, ICredentials <SecureString> credentials, ICodePaneWrapperFactory wrapperFactory)
            : this(project, repository, wrapperFactory)
        {
            _credentials = new SecureUsernamePasswordCredentials()
            {
                Username = credentials.Username,
                Password = credentials.Password
            };

            _credentialsHandler = (url, user, cred) => _credentials;
        }
Пример #18
0
        public GitProvider(IVBProject project, IRepository repository, ICredentials <SecureString> secureCredentials)
            : this(project, repository)
        {
            _credentials = new SecureUsernamePasswordCredentials()
            {
                Username = secureCredentials.Username,
                Password = secureCredentials.Password
            };

            _credentialsHandler = (url, user, cred) => _credentials;
        }
Пример #19
0
        public GitProvider(VBProject project, IRepository repository, string userName, string passWord, ICodePaneWrapperFactory wrapperFactory)
            : this(project, repository, wrapperFactory)
        {
            _credentials = new UsernamePasswordCredentials()
            {
                Username = userName,
                Password = passWord
            };

            _credentialsHandler = (url, user, cred) => _credentials;
        }
Пример #20
0
        public GitProvider(VBProject project, IRepository repository, ICredentials<SecureString> credentials, ICodePaneWrapperFactory wrapperFactory)
            : this(project, repository, wrapperFactory)
        {
            _credentials = new SecureUsernamePasswordCredentials()
            {
                Username = credentials.Username,
                Password = credentials.Password
            };

            _credentialsHandler = (url, user, cred) => _credentials;
        }
Пример #21
0
        public GitProvider(VBProject project, RepositorySettings repository, string userName, string passWord)
            : this(project, repository)
        {
            _credentials = new UsernamePasswordCredentials()
            {
                Username = userName,
                Password = passWord
            };

            _credentialsHandler = (url, user, cred) => _credentials;
        }
Пример #22
0
 internal RemoteCallbacks(
     ProgressHandler onProgress = null,
     TransferProgressHandler onDownloadProgress = null,
     UpdateTipsHandler onUpdateTips = null,
     CredentialsHandler credentialsProvider = null)
 {
     Progress = onProgress;
     DownloadTransferProgress = onDownloadProgress;
     UpdateTips = onUpdateTips;
     CredentialsProvider = credentialsProvider;
 }
Пример #23
0
 internal RemoteCallbacks(
     ProgressHandler onProgress = null,
     TransferProgressHandler onDownloadProgress = null,
     UpdateTipsHandler onUpdateTips             = null,
     CredentialsHandler credentialsProvider     = null)
 {
     Progress = onProgress;
     DownloadTransferProgress = onDownloadProgress;
     UpdateTips          = onUpdateTips;
     CredentialsProvider = credentialsProvider;
 }
Пример #24
0
        public static void ResetTag(string tag, PathConstruction.AbsolutePath projectPath, string repositoryUrl,
                                    CredentialsHandler credentialsHandler = null)
        {
            var repository = GitRepositoryBuilder.GetRepository(repositoryUrl, projectPath, credentialsHandler);

            if (repository.Tags.Any(s => string.Equals(s.FriendlyName, tag, StringComparison.OrdinalIgnoreCase)))
            {
                DeleteTag(tag, projectPath, repositoryUrl, credentialsHandler);
            }

            CreateTag(tag, projectPath, repositoryUrl, credentialsHandler);
        }
        public void Initialize()
        {
            _logger.LogInformation("Initializing {Name} provider with options {Options}.", Name, new
            {
                _providerOptions.RepositoryUrl,
                _providerOptions.LocalPath,
                _providerOptions.Branch,
                _providerOptions.PollingInterval,
                _providerOptions.SearchPattern
            });

            if (Directory.Exists(_providerOptions.LocalPath))
            {
                _logger.LogInformation("A local repository already exists at {LocalPath}.", _providerOptions.LocalPath);

                _logger.LogInformation("Deleting directory {LocalPath}.", _providerOptions.LocalPath);

                DeleteDirectory(_providerOptions.LocalPath);
            }

            if (!Directory.Exists(_providerOptions.LocalPath))
            {
                _logger.LogInformation("Creating directory {LocalPath}.", _providerOptions.LocalPath);

                Directory.CreateDirectory(_providerOptions.LocalPath);
            }

            if (_providerOptions.Username != null && _providerOptions.Password != null)
            {
                _credentialsHandler = (url, user, cred) => new UsernamePasswordCredentials
                {
                    Username = _providerOptions.Username,
                    Password = _providerOptions.Password
                };
            }

            var cloneOptions = new CloneOptions
            {
                CredentialsProvider = _credentialsHandler,
                BranchName          = _providerOptions.Branch
            };

            _logger.LogInformation("Cloning git repository {RepositoryUrl} to {LocalPath}.", _providerOptions.RepositoryUrl, _providerOptions.LocalPath);

            var path = Repository.Clone(_providerOptions.RepositoryUrl, _providerOptions.LocalPath, cloneOptions);

            _logger.LogInformation("Repository cloned to {path}.", path);

            using var repo = new Repository(_providerOptions.LocalPath);
            var hash = repo.Head.Tip.Sha.Substring(0, 6);

            _logger.LogInformation("Current HEAD is [{hash}] '{MessageShort}'.", hash, repo.Head.Tip.MessageShort);
        }
Пример #26
0
        private static object @lock = new object();         // Потокобезопасность не гарантируется библиотекой libgit2

        // url example [email protected]:user/myrepo.git
        public GitRepo(string url, DirectoryInfo reposBaseDir, string publicKey, string privateKey, DirectoryInfo keysTempDirectory, ILogger logger)
        {
            this.url          = url;
            this.reposBaseDir = reposBaseDir;
            this.logger       = logger;
            if (!reposBaseDir.Exists)
            {
                reposBaseDir.Create();
            }

            Monitor.Enter(@lock);

            var filenameGuid = Guid.NewGuid().ToString();

            privateKeyPath = Path.Combine(keysTempDirectory.FullName, filenameGuid);
            publicKeyPath  = privateKeyPath + ".pub";
            File.WriteAllText(privateKeyPath, privateKey);
            File.WriteAllText(publicKeyPath, publicKey);
            credentialsHandler = (_, __, ___) => new SshUserKeyCredentials
            {
                Username   = "******",
                Passphrase = "",
                PublicKey  = publicKeyPath,
                PrivateKey = privateKeyPath,
            };

            try
            {
                if (!TryUpdateExistingRepo())
                {
                    Clone();
                }
            }
            catch (LibGit2SharpException ex)
            {
                Dispose();                 // Если объект не создан, извне Dispose не вызовут
                if (ex.Message.Contains("SSH"))
                {
                    throw new GitException(ex.Message, ex)
                          {
                              MayBeSSHException = true
                          }
                }
                ;
                throw;
            }
            catch (Exception ex)
            {
                Dispose();                 // Если объект не создан, извне Dispose не вызовут
                throw;
            }
        }
        private CredentialsHandler GetCredentialsHandler()
        {
            string user    = Environment.GetEnvironmentVariable("GH_USER");
            string token   = Environment.GetEnvironmentVariable("GH_TOKEN");
            var    handler = new CredentialsHandler(
                (url, usernameFromUrl, types) => new UsernamePasswordCredentials()
            {
                Username = usernameFromUrl ?? user,
                Password = token
            });

            return(handler);
        }
Пример #28
0
        internal RemoteCallbacks(PushOptions pushOptions)
        {
            if (pushOptions == null)
            {
                return;
            }

            PushTransferProgress = pushOptions.OnPushTransferProgress;
            PackBuilderProgress = pushOptions.OnPackBuilderProgress;
            CredentialsProvider = pushOptions.CredentialsProvider;
            CertificateCheck = pushOptions.CertificateCheck;
            PushStatusError = pushOptions.OnPushStatusError;
            PrePushCallback = pushOptions.OnNegotiationCompletedBeforePush;
        }
Пример #29
0
 public static void PushChanges(Repository repository, CredentialsHandler credentialsHandler, string remote, string branch, string tagName)
 {
     try
       {
     var remotes = repository.Network.Remotes[remote];
     var options = new PushOptions {CredentialsProvider = credentialsHandler};
     string pushRefSpec = string.Format("refs/heads/{0}:refs/tags/{1}", branch, tagName);
     repository.Network.Push(remotes, pushRefSpec, options);
       }
       catch (Exception e)
       {
     Console.WriteLine("Exception:RepoActions:PushChanges " + e.Message);
       }
 }
Пример #30
0
        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);
        }
Пример #31
0
        /// <inheritdoc />
        public static IObservable <IObservableRepository> Clone(
            string sourceUrl,
            string workingDirectory,
            IObserver <Tuple <string, int> > observer,
            CredentialsHandler credentials = null)
        {
            var isCancelled = false;
            var options     = new CloneOptions
            {
                Checkout            = true,
                CredentialsProvider = credentials,
                OnTransferProgress  = progress =>
                {
                    // TODO: how should we signal for the "indexing objects" events
                    var p = (100 * progress.ReceivedObjects) / progress.TotalObjects;
                    var receivingMessage = String.Format("Receiving objects:  {0}% ({1}/{2})", p, progress.ReceivedObjects, progress.TotalObjects);
                    observer.OnNext(Tuple.Create(receivingMessage, p));
                    return(!isCancelled);
                },
                IsBare             = false,
                OnCheckoutProgress = ProgressFactory.CreateHandlerWithoutMessages(observer)
            };

            var directoryInfo  = new DirectoryInfo(workingDirectory);
            var initialMessage = String.Format("Cloning into '{0}'...", directoryInfo.Name);

            observer.OnNext(Tuple.Create(initialMessage, 0));

            return(Observable.Create <ObservableRepository>(subj =>
            {
                var sub = Observable.Start(() =>
                {
                    var directory = Repository.Clone(sourceUrl, workingDirectory, options);

                    observer.OnNext(Tuple.Create("clone completed", 100));
                    observer.OnCompleted();

                    return new ObservableRepository(directory, credentials);
                }, Scheduler.Default).Subscribe(subj);

                return new CompositeDisposable(
                    sub,
                    Disposable.Create(() =>
                {
                    isCancelled = true;
                    observer.OnCompleted();
                }));
            }));
        }
Пример #32
0
        public void LoadRepo(Repo repoToLoad)
        {
            _repo?.Dispose();

            var localRepoRelativePath = repoToLoad.FriendlyName.ToLower().Replace(" ", "_");
            var localRepoAbsolutePath = Path.Combine(AppContext.BaseDirectory, "reposcache", localRepoRelativePath);

            CredentialsHandler credentialsHandler = null;

            if (!string.IsNullOrEmpty(_settings.Username))
            {
                credentialsHandler = (url, usernameFromUrl, types) =>
                                     new UsernamePasswordCredentials
                {
                    Username = _settings.Username,
                    Password = _settings.Password
                };
            }

            bool recentlyCloned = false;

            if (!Directory.Exists(localRepoAbsolutePath))
            {
                var cloneOptions = new CloneOptions();
                if (credentialsHandler != null)
                {
                    cloneOptions.CredentialsProvider = credentialsHandler;
                }

                Repository.Clone(repoToLoad.Url, localRepoAbsolutePath, cloneOptions);
                _logger.LogInformation($"Cloned {repoToLoad.Url} to folder {localRepoAbsolutePath}");
                recentlyCloned = true;
            }

            _repo = new Repository(localRepoAbsolutePath);

            if (!recentlyCloned)
            {
                var fetchOptions = new FetchOptions();
                if (credentialsHandler != null)
                {
                    fetchOptions.CredentialsProvider = credentialsHandler;
                }
                var remote   = _repo.Network.Remotes.First(r => r.Name == "origin");
                var refSpecs = remote.FetchRefSpecs.Select(x => x.Specification);
                Commands.Fetch(_repo, remote.Name, refSpecs, fetchOptions, "");
                _logger.LogInformation($"Fetched origin for {repoToLoad.FriendlyName} in folder {localRepoAbsolutePath}");
            }
        }
Пример #33
0
        /// <summary>
        /// Pushes the local branch to the given remote.
        /// </summary>
        /// <returns>The name of the branch it's been pushed to.</returns>
        private string PushBranch(Repository repo, Remote origin, string gitHubToken)
        {
            var currentBranch              = repo.Head;
            var remoteBranchName           = $"release-pr-{DateTime.UtcNow:yyyyMMddTHHmmss'Z'}";
            CredentialsHandler credentials = (url, user, cred) => new UsernamePasswordCredentials {
                Username = gitHubToken, Password = ""
            };

            // TODO: Work out why I can't pass currentBranch.FriendlyName in as the src.
            repo.Network.Push(origin, $"HEAD:refs/heads/{remoteBranchName}", new PushOptions {
                CredentialsProvider = credentials
            });

            return(remoteBranchName);
        }
Пример #34
0
        public FetchCommand(
            IEnumerable <CherryPickConfig> repositories,
            IEventStream eventStream,
            CredentialsHandler credentials,
            CherryPickerView view,
            MainThread mainThread)
        {
            this.repositories = repositories;
            this.eventStream  = eventStream;
            this.credentials  = credentials;
            this.view         = view;
            this.mainThread   = mainThread;

            IsVisible = IsEnabled = !view.IsRootMode;
        }
Пример #35
0
 public static void PushChanges(Repository repository, CredentialsHandler credentialsHandler, string remote, string branch, string tagName)
 {
     try
     {
         var remotes = repository.Network.Remotes[remote];
         var options = new PushOptions {
             CredentialsProvider = credentialsHandler
         };
         string pushRefSpec = string.Format("refs/heads/{0}:refs/tags/{1}", branch, tagName);
         repository.Network.Push(remotes, pushRefSpec, options);
     }
     catch (Exception e)
     {
         Console.WriteLine("Exception:RepoActions:PushChanges " + e.Message);
     }
 }
Пример #36
0
        /// <summary>
        /// List references in a <see cref="Remote"/> repository.
        /// <para>
        /// When the remote tips are ahead of the local ones, the retrieved
        /// <see cref="DirectReference"/>s may point to non existing
        /// <see cref="GitObject"/>s in the local repository. In that
        /// case, <see cref="DirectReference.Target"/> will return <c>null</c>.
        /// </para>
        /// </summary>
        /// <param name="remote">The <see cref="Remote"/> to list from.</param>
        /// <param name="credentialsProvider">The optional <see cref="Func{Credentials}"/> used to connect to remote repository.</param>
        /// <returns>The references in the <see cref="Remote"/> repository.</returns>
        public virtual IEnumerable<DirectReference> ListReferences(Remote remote, CredentialsHandler credentialsProvider = null)
        {
            Ensure.ArgumentNotNull(remote, "remote");

            using (RemoteSafeHandle remoteHandle = Proxy.git_remote_load(repository.Handle, remote.Name, true))
            {
                if (credentialsProvider != null)
                {
                    var callbacks = new RemoteCallbacks(null, null, null, credentialsProvider);
                    GitRemoteCallbacks gitCallbacks = callbacks.GenerateCallbacks();
                    Proxy.git_remote_set_callbacks(remoteHandle, ref gitCallbacks);
                }

                Proxy.git_remote_connect(remoteHandle, GitDirection.Fetch);
                return Proxy.git_remote_ls(repository, remoteHandle);
            }
        }
Пример #37
0
        /// <summary>
        /// List references in a <see cref="Remote"/> repository.
        /// <para>
        /// When the remote tips are ahead of the local ones, the retrieved
        /// <see cref="DirectReference"/>s may point to non existing
        /// <see cref="GitObject"/>s in the local repository. In that
        /// case, <see cref="DirectReference.Target"/> will return <c>null</c>.
        /// </para>
        /// </summary>
        /// <param name="remote">The <see cref="Remote"/> to list from.</param>
        /// <param name="credentialsProvider">The optional <see cref="Func{Credentials}"/> used to connect to remote repository.</param>
        /// <returns>The references in the <see cref="Remote"/> repository.</returns>
        public virtual IEnumerable <DirectReference> ListReferences(Remote remote, CredentialsHandler credentialsProvider = null)
        {
            Ensure.ArgumentNotNull(remote, "remote");

            using (RemoteSafeHandle remoteHandle = Proxy.git_remote_lookup(repository.Handle, remote.Name, true))
            {
                if (credentialsProvider != null)
                {
                    var callbacks = new RemoteCallbacks(credentialsProvider);
                    GitRemoteCallbacks gitCallbacks = callbacks.GenerateCallbacks();
                    Proxy.git_remote_set_callbacks(remoteHandle, ref gitCallbacks);
                }

                Proxy.git_remote_connect(remoteHandle, GitDirection.Fetch);
                return(Proxy.git_remote_ls(repository, remoteHandle));
            }
        }
Пример #38
0
        internal RemoteCallbacks(FetchOptionsBase fetchOptions)
        {
            if (fetchOptions == null)
            {
                return;
            }

            Progress = fetchOptions.OnProgress;
            DownloadTransferProgress = fetchOptions.OnTransferProgress;
            UpdateTips = fetchOptions.OnUpdateTips;
            CredentialsProvider = fetchOptions.CredentialsProvider;
            CertificateCheck = fetchOptions.CertificateCheck;
        }
Пример #39
0
        /// <summary>
        /// List references in a <see cref="Remote"/> repository.
        /// <para>
        /// When the remote tips are ahead of the local ones, the retrieved
        /// <see cref="DirectReference"/>s may point to non existing
        /// <see cref="GitObject"/>s in the local repository. In that
        /// case, <see cref="DirectReference.Target"/> will return <c>null</c>.
        /// </para>
        /// </summary>
        /// <param name="remote">The <see cref="Remote"/> to list from.</param>
        /// <param name="credentialsProvider">The <see cref="Func{Credentials}"/> used to connect to remote repository.</param>
        /// <returns>The references in the <see cref="Remote"/> repository.</returns>
        public virtual IEnumerable<Reference> ListReferences(Remote remote, CredentialsHandler credentialsProvider)
        {
            Ensure.ArgumentNotNull(remote, "remote");
            Ensure.ArgumentNotNull(credentialsProvider, "credentialsProvider");

            return ListReferencesInternal(remote.Url, credentialsProvider);
        }
Пример #40
0
 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 };
 }
Пример #41
0
        /// <summary>
        /// List references in a remote repository.
        /// <para>
        /// When the remote tips are ahead of the local ones, the retrieved
        /// <see cref="DirectReference"/>s may point to non existing
        /// <see cref="GitObject"/>s in the local repository. In that
        /// case, <see cref="DirectReference.Target"/> will return <c>null</c>.
        /// </para>
        /// </summary>
        /// <param name="url">The url to list from.</param>
        /// <param name="credentialsProvider">The <see cref="Func{Credentials}"/> used to connect to remote repository.</param>
        /// <returns>The references in the remote repository.</returns>
        public virtual IEnumerable<Reference> ListReferences(string url, CredentialsHandler credentialsProvider)
        {
            Ensure.ArgumentNotNull(url, "url");
            Ensure.ArgumentNotNull(credentialsProvider, "credentialsProvider");

            return ListReferencesInternal(url, credentialsProvider);
        }
Пример #42
0
 public CredentialProvider(IScreen screen, ICredentialStore credentialStore)
 {
     this.store = credentialStore;
     this.CredentialHandler = new CredentialsHandler(this.OnCredentialsRequested);
 }
Пример #43
0
        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);
            }
        }
Пример #44
0
 internal RemoteCallbacks(CredentialsHandler credentialsProvider)
 {
     CredentialsProvider = credentialsProvider;
 }