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); } } }
private static void Main(string[] args) { var result = CommandLine.Parser.Default.ParseArguments<Options>(args); if (!result.Errors.Any()) { string url = result.Value.Repository; var brancOption = result.Value.Branch; var branchSepIndex = brancOption.IndexOf('/'); if (branchSepIndex > 0) { var credentials = new UsernamePasswordCredentials { Username = result.Value.UserName, Password = result.Value.Password }; CredentialsHandler credHandler = (s, fromUrl, types) => credentials; var remote = brancOption.Substring(0, branchSepIndex); var branch = brancOption.Substring(branchSepIndex+1, brancOption.Length - branchSepIndex-1); var workingDirectory = result.Value.LocalRepoPath; var isLocalRepoExist = Repository.Discover(workingDirectory); if (isLocalRepoExist == null) { var cloneOptions = new CloneOptions {CredentialsProvider = credHandler}; Repository.Clone(url, workingDirectory, cloneOptions); } Repository repo = null; try { var tagName = result.Value.TagName; repo = new Repository(workingDirectory); //repo.Fetch(remote, new FetchOptions(){CredentialsProvider = credHandler}); repo.Network.Pull(new Signature(result.Value.UserName,result.Value.Email, new DateTimeOffset()), new PullOptions() { FetchOptions = new FetchOptions() { CredentialsProvider = credHandler } }); repo.ApplyTag(tagName); PushChanges(repo, credHandler, remote, branch, tagName); Console.WriteLine("Tagged :{0}", result.Value.TagName); } catch (Exception ex) { Console.WriteLine("Error happened {0}", ex.Message); } finally { if (repo != null) repo.Dispose(); } } } Console.ReadLine(); }
string GetGitInfoFromUrl() { var gitDirectory = Path.Combine(arguments.TargetPath, "_dynamicrepository", ".git"); if (Directory.Exists(gitDirectory)) { Logger.WriteInfo(string.Format("Deleting existing .git folder from '{0}' to force new checkout from url", gitDirectory)); DeleteHelper.DeleteGitRepository(gitDirectory); } Credentials credentials = null; var authentication = arguments.Authentication; if (!string.IsNullOrWhiteSpace(authentication.Username) && !string.IsNullOrWhiteSpace(authentication.Password)) { Logger.WriteInfo(string.Format("Setting up credentials using name '{0}'", authentication.Username)); credentials = new UsernamePasswordCredentials { Username = authentication.Username, Password = authentication.Password }; } Logger.WriteInfo(string.Format("Retrieving git info from url '{0}'", arguments.TargetUrl)); Repository.Clone(arguments.TargetUrl, gitDirectory, new CloneOptions { IsBare = true, Checkout = false, CredentialsProvider = (url, user, types) => credentials }); if (!string.IsNullOrWhiteSpace(arguments.TargetBranch)) { // Normalize (download branches) before using the branch GitHelper.NormalizeGitDirectory(gitDirectory, arguments.Authentication); using (var repository = new Repository(gitDirectory)) { var targetBranchName = string.Format("refs/heads/{0}", arguments.TargetBranch); if (!string.Equals(repository.Head.CanonicalName, targetBranchName)) { Logger.WriteInfo(string.Format("Switching to branch '{0}'", arguments.TargetBranch)); repository.Refs.UpdateTarget("HEAD", targetBranchName); } repository.CheckoutFilesIfExist("NextVersion.txt"); } } DynamicGitRepositoryPath = gitDirectory; return gitDirectory; }
/// <summary> /// Acquires credentials. /// </summary> /// <param name="cred">Receives the credentials if the operation is successful.</param> /// <param name="user">The username.</param> /// <param name="methods">The credential types allowed. The only supported one is <see cref="UsernamePasswordCredentials"/>. May be empty but should not be null.</param> /// <returns>0 if successful; a non-zero error code that came from <see cref="Proxy.git_transport_smart_credentials"/> otherwise.</returns> public int AcquireCredentials(out Credentials cred, string user, params Type[] methods) { // Convert the user-provided types to libgit2's flags int allowed = 0; foreach (var method in methods) { if (method == typeof(UsernamePasswordCredentials)) { allowed |= (int)GitCredentialType.UserPassPlaintext; } else if (method == typeof(DefaultCredentials)) { allowed |= (int)GitCredentialType.Default; } else { throw new InvalidOperationException("Unknown type passes as allowed credential"); } } IntPtr credHandle = IntPtr.Zero; int res = Proxy.git_transport_smart_credentials(out credHandle, Transport, user, allowed); if (res != 0) { cred = null; return res; } if (credHandle == IntPtr.Zero) { throw new InvalidOperationException("credentials callback indicated success but returned no credentials"); } unsafe { var baseCred = (GitCredential*) credHandle; switch (baseCred->credtype) { case GitCredentialType.UserPassPlaintext: cred = UsernamePasswordCredentials.FromNative((GitCredentialUserpass*) credHandle); return 0; case GitCredentialType.Default: cred = new DefaultCredentials(); return 0; default: throw new InvalidOperationException("User returned an unkown credential type"); } } }
/// <summary> /// Pull changes from remote to local, cross fingers no merge pls. /// </summary> /// <param name="credentials">User:Pass credentials</param> public void Pull(UsernamePasswordCredentials credentials) { using (var repo = new Repository(_LocalRepo)) { var pullOptions = new PullOptions { FetchOptions = new FetchOptions { CredentialsProvider = (url, username, types) => credentials } }; repo.Network.Pull(new Signature("Chuck Interface","--", new DateTimeOffset(DateTime.Now)), pullOptions); } }
public int AcquireCredentials(out Credentials cred, string user, params Type[] methods) { // Convert the user-provided types to libgit2's flags int allowed = 0; foreach (var method in methods) { if (method == typeof(UsernamePasswordCredentials)) { allowed |= (int)GitCredentialType.UserPassPlaintext; } else { throw new InvalidOperationException("Unknown type passes as allowed credential"); } } IntPtr credHandle = IntPtr.Zero; int res = Proxy.git_transport_smart_credentials(out credHandle, Transport, user, allowed); if (res != 0) { cred = null; return(res); } var baseCred = credHandle.MarshalAs <GitCredential>(); switch (baseCred.credtype) { case GitCredentialType.UserPassPlaintext: cred = UsernamePasswordCredentials.FromNative(credHandle.MarshalAs <GitCredentialUserpass>()); return(0); default: throw new InvalidOperationException("User returned an unkown credential type"); } }
public static Credentials TryGet (string url, string userFromUrl, SupportedCredentialTypes types, GitCredentialsType type) { bool result = true; Uri uri = null; GitCredentialsState state; if (!credState.TryGetValue (type, out state)) credState [type] = state = new GitCredentialsState (); state.UrlUsed = url; // We always need to run the TryGet* methods as we need the passphraseItem/passwordItem populated even // if the password store contains an invalid password/no password if ((types & SupportedCredentialTypes.UsernamePassword) != 0) { uri = new Uri (url); string username; string password; if (!state.NativePasswordUsed && TryGetUsernamePassword (uri, out username, out password)) { state.NativePasswordUsed = true; return new UsernamePasswordCredentials { Username = username, Password = password }; } } Credentials cred; if ((types & SupportedCredentialTypes.UsernamePassword) != 0) cred = new UsernamePasswordCredentials (); else { // Try ssh-agent on Linux. if (!Platform.IsWindows && !state.AgentUsed) { bool agentUsable; if (!state.AgentForUrl.TryGetValue (url, out agentUsable)) state.AgentForUrl [url] = agentUsable = true; if (agentUsable) { state.AgentUsed = true; return new SshAgentCredentials { Username = userFromUrl, }; } } int key; if (!state.KeyForUrl.TryGetValue (url, out key)) { if (state.KeyUsed + 1 < Keys.Count) state.KeyUsed++; else { SelectFileDialog dlg = null; bool success = false; DispatchService.GuiSyncDispatch (() => { dlg = new SelectFileDialog (GettextCatalog.GetString ("Select a private SSH key to use.")); dlg.ShowHidden = true; dlg.CurrentFolder = Environment.GetFolderPath (Environment.SpecialFolder.Personal); success = dlg.Run (); }); if (!success || !File.Exists (dlg.SelectedFile + ".pub")) throw new VersionControlException (GettextCatalog.GetString ("Invalid credentials were supplied. Aborting operation.")); cred = new SshUserKeyCredentials { Username = userFromUrl, Passphrase = "", PrivateKey = dlg.SelectedFile, PublicKey = dlg.SelectedFile + ".pub", }; if (KeyHasPassphrase (dlg.SelectedFile)) { DispatchService.GuiSyncDispatch (delegate { using (var credDlg = new CredentialsDialog (url, types, cred)) result = MessageService.ShowCustomDialog (credDlg) == (int)Gtk.ResponseType.Ok; }); } if (result) return cred; throw new VersionControlException (GettextCatalog.GetString ("Invalid credentials were supplied. Aborting operation.")); } } else state.KeyUsed = key; cred = new SshUserKeyCredentials { Username = userFromUrl, Passphrase = "", PrivateKey = Keys [state.KeyUsed], PublicKey = Keys [state.KeyUsed] + ".pub", }; return cred; } DispatchService.GuiSyncDispatch (delegate { using (var credDlg = new CredentialsDialog (url, types, cred)) result = MessageService.ShowCustomDialog (credDlg) == (int)Gtk.ResponseType.Ok; }); if (result) { if ((types & SupportedCredentialTypes.UsernamePassword) != 0) { var upcred = (UsernamePasswordCredentials)cred; if (!string.IsNullOrEmpty (upcred.Password)) { PasswordService.AddWebUserNameAndPassword (uri, upcred.Username, upcred.Password); } } } return cred; }
static void CloneRepository(string repositoryUrl, string gitDirectory, AuthenticationInfo authentication) { Credentials credentials = null; if (!string.IsNullOrWhiteSpace(authentication.Username) && !string.IsNullOrWhiteSpace(authentication.Password)) { Logger.WriteInfo(string.Format("Setting up credentials using name '{0}'", authentication.Username)); credentials = new UsernamePasswordCredentials { Username = authentication.Username, Password = authentication.Password }; } Logger.WriteInfo(string.Format("Retrieving git info from url '{0}'", repositoryUrl)); try { var cloneOptions = new CloneOptions { Checkout = false, CredentialsProvider = (url, usernameFromUrl, types) => credentials }; var returnedPath = Repository.Clone(repositoryUrl, gitDirectory, cloneOptions); Logger.WriteInfo(string.Format("Returned path after repository clone: {0}", returnedPath)); } catch (LibGit2SharpException ex) { var message = ex.Message; if (message.Contains("401")) { throw new Exception("Unauthorised: Incorrect username/password"); } if (message.Contains("403")) { throw new Exception("Forbidden: Possbily Incorrect username/password"); } if (message.Contains("404")) { throw new Exception("Not found: The repository was not found"); } throw new Exception("There was an unknown problem with the Git repository you provided", ex); } }
private static IGitRepositoryContextFactory GetRepositoryFactory(bool isRemote, string workingDir, Context context, IFileSystem fileSystem) { IGitRepositoryContextFactory gitRepoFactory = null; if (isRemote) { // clone repo from the remote url var cloneRepoArgs = new GitRemoteRepositoryContextFactory.RemoteRepoArgs(); cloneRepoArgs.Url = context.Repository.Url; cloneRepoArgs.Branch = context.Repository.Branch; var credentials = new UsernamePasswordCredentials(); credentials.Username = context.Repository.Username; credentials.Password = context.Repository.Password; cloneRepoArgs.Credentials = credentials; cloneRepoArgs.DestinationPath = workingDir; Log.WriteLine("Cloning a git repo from {0}", cloneRepoArgs.Url); gitRepoFactory = new GitRemoteRepositoryContextFactory(cloneRepoArgs, fileSystem); } else { gitRepoFactory = new GitLocalRepositoryContextFactory(workingDir, fileSystem); } return gitRepoFactory; }
static string CreateDynamicRepository(string targetPath, Authentication authentication, string repositoryUrl, string targetBranch, bool noFetch) { Logger.WriteInfo(string.Format("Creating dynamic repository at '{0}'", targetPath)); var gitDirectory = Path.Combine(targetPath, ".git"); if (Directory.Exists(targetPath)) { Logger.WriteInfo("Git repository already exists"); GitHelper.NormalizeGitDirectory(gitDirectory, authentication, noFetch); Logger.WriteInfo(string.Format("Updating branch '{0}'", targetBranch)); using (var repo = new Repository(targetPath)) { if (string.IsNullOrWhiteSpace(targetBranch)) { throw new Exception("Dynamic Git repositories must have a target branch (/b)"); } var targetGitBranch = repo.Branches[targetBranch]; var trackedBranch = targetGitBranch.TrackedBranch; if (trackedBranch == null) throw new InvalidOperationException(string.Format("Expecting {0} to have a remote tracking branch", targetBranch)); targetGitBranch.Checkout(); repo.Reset(ResetMode.Hard, trackedBranch.Tip); } return gitDirectory; } Credentials credentials = null; if (!string.IsNullOrWhiteSpace(authentication.Username) && !string.IsNullOrWhiteSpace(authentication.Password)) { Logger.WriteInfo(string.Format("Setting up credentials using name '{0}'", authentication.Username)); credentials = new UsernamePasswordCredentials { Username = authentication.Username, Password = authentication.Password }; } Logger.WriteInfo(string.Format("Retrieving git info from url '{0}'", repositoryUrl)); CloneRepository(repositoryUrl, gitDirectory, credentials); // Normalize (download branches) before using the branch GitHelper.NormalizeGitDirectory(gitDirectory, authentication, noFetch); using (var repository = new Repository(gitDirectory)) { if (string.IsNullOrWhiteSpace(targetBranch)) { targetBranch = repository.Head.Name; } Reference newHead = null; var localReference = GetLocalReference(repository, targetBranch); if (localReference != null) { newHead = localReference; } if (newHead == null) { var remoteReference = GetRemoteReference(repository, targetBranch, repositoryUrl, authentication); if (remoteReference != null) { repository.Network.Fetch(repositoryUrl, new[] { string.Format("{0}:{1}", remoteReference.CanonicalName, targetBranch) }); newHead = repository.Refs[string.Format("refs/heads/{0}", targetBranch)]; } } if (newHead != null) { Logger.WriteInfo(string.Format("Switching to branch '{0}'", targetBranch)); repository.Refs.UpdateTarget(repository.Refs.Head, newHead); } } return gitDirectory; }
private string GetGitInfoFromUrl(Context context, string gitDirectory) { gitDirectory = Path.Combine(gitDirectory, ".git"); if (Directory.Exists(gitDirectory)) { Log.Info("Deleting existing .git folder from '{0}' to force new checkout from url", gitDirectory); DeleteHelper.DeleteGitRepository(gitDirectory); } Log.Info("Retrieving git info from url '{0}'", context.TargetUrl); Credentials credentials = null; var authentication = context.Authentication; if (!string.IsNullOrWhiteSpace(authentication.Username) && !string.IsNullOrWhiteSpace(authentication.Password)) { Log.Info("Setting up credentials using name '{0}'", authentication.Username); credentials = new UsernamePasswordCredentials { Username = authentication.Username, Password = authentication.Password }; } var cloneOptions = new CloneOptions { Checkout = false, IsBare = true, CredentialsProvider = (url, username, supportedTypes) => credentials }; Repository.Clone(context.TargetUrl, gitDirectory, cloneOptions); if (!string.IsNullOrWhiteSpace(context.TargetBranch)) { using (var repository = new Repository(gitDirectory)) { Reference newHead = null; var localReference = GetLocalReference(repository, context.TargetBranch); if (localReference != null) { newHead = localReference; } if (newHead == null) { var remoteReference = GetRemoteReference(repository, context.TargetBranch, context.TargetUrl); if (remoteReference != null) { repository.Network.Fetch(context.TargetUrl, new[] { string.Format("{0}:{1}", remoteReference.CanonicalName, context.TargetBranch) }); newHead = repository.Refs[string.Format("refs/heads/{0}", context.TargetBranch)]; } } if (newHead != null) { Log.Info("Switching to branch '{0}'", context.TargetBranch); repository.Refs.UpdateTarget(repository.Refs.Head, newHead); } } } return gitDirectory; }
private CredentialsHandler GetSourceCredentialsHandler() { var credentials = new UsernamePasswordCredentials() { Username = SourceUserName, Password = SourcePassword }; CredentialsHandler credentialHandler = (_url, _user, _cred) => credentials; return credentialHandler; }
/// <summary> /// Push local changes to remote, no merge conflicts pls.... /// </summary> /// <param name="credentials">The credentials of the user who is pushing this.</param> public string Push(UsernamePasswordCredentials credentials) { using (var repo = new Repository(_LocalRepo)) { var pushOptions = new PushOptions { CredentialsProvider = (url, username, types) => credentials }; //: TODO - Add support for choosing which branch try { repo.Network.Push(repo.Branches["master"], pushOptions); } catch (LibGit2SharpException e) { return e.Message; } } //: No errors! return string.Empty; }
/// <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); }
static string CreateDynamicRepository(string targetPath, Authentication authentication, string repositoryUrl, string targetBranch, bool noFetch) { var gitDirectory = Path.Combine(targetPath, ".git"); if (Directory.Exists(targetPath)) { Logger.WriteInfo("Git repository already exists at {0}, skipping clone"); return gitDirectory; } Credentials credentials = null; if (!string.IsNullOrWhiteSpace(authentication.Username) && !string.IsNullOrWhiteSpace(authentication.Password)) { Logger.WriteInfo(string.Format("Setting up credentials using name '{0}'", authentication.Username)); credentials = new UsernamePasswordCredentials { Username = authentication.Username, Password = authentication.Password }; } Logger.WriteInfo(string.Format("Retrieving git info from url '{0}'", repositoryUrl)); Repository.Clone(repositoryUrl, gitDirectory, new CloneOptions { IsBare = true, Checkout = false, CredentialsProvider = (url, usernameFromUrl, types) => credentials }); // Normalize (download branches) before using the branch GitHelper.NormalizeGitDirectory(gitDirectory, authentication, noFetch); using (var repository = new Repository(gitDirectory)) { if (string.IsNullOrWhiteSpace(targetBranch)) { targetBranch = repository.Head.Name; } Reference newHead = null; var localReference = GetLocalReference(repository, targetBranch); if (localReference != null) { newHead = localReference; } if (newHead == null) { var remoteReference = GetRemoteReference(repository, targetBranch, repositoryUrl); if (remoteReference != null) { repository.Network.Fetch(repositoryUrl, new[] { string.Format("{0}:{1}", remoteReference.CanonicalName, targetBranch) }); newHead = repository.Refs[string.Format("refs/heads/{0}", targetBranch)]; } } if (newHead != null) { Logger.WriteInfo(string.Format("Switching to branch '{0}'", targetBranch)); repository.Refs.UpdateTarget(repository.Refs.Head, newHead); } } return gitDirectory; }