/// <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(); })); }); }
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); }
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 GitRepositoryContext GetRepositoryContext() { args.Validate(); var gitRootDirectory = Path.Combine(args.DestinationPath); var gitDirectory = Path.Combine(gitRootDirectory, ".git"); if (Directory.Exists(gitDirectory)) { Log.WriteLine("Deleting existing .git folder from '{0}' to force new checkout from url", gitDirectory); DeleteGitDirectory(gitDirectory); } var credentials = args.Credentials; Log.WriteLine("Retrieving git info from url '{0}'", args.Url); var cloneOptions = new CloneOptions(); cloneOptions.IsBare = true; cloneOptions.Checkout = false; cloneOptions.CredentialsProvider = (url, usernameFromUrl, types) => credentials; var repoPath = Repository.Clone(args.Url, gitDirectory, cloneOptions); var repository = new Repository(repoPath); var repoContext = new GitRepositoryContext(repository, credentials, true, args.Url); return repoContext; }
public GitRepositoryContext GetRepositoryContext() { args.Validate(); var gitRootDirectory = Path.Combine(args.DestinationPath); var gitDirectory = Path.Combine(gitRootDirectory, ".git"); var credentials = args.Credentials; if (fileSystem.DirectoryExists(gitDirectory)) { Log.WriteLine("Git repository already exists, using existing instance from url '{0}'", args.Url); var repository = new Repository(gitDirectory); var repoContext = new GitRepositoryContext(repository, credentials, true, args.Url, fileSystem); return repoContext; } else { Log.WriteLine("Cloning git repository from url '{0}'", args.Url); var cloneOptions = new CloneOptions { IsBare = true, Checkout = false, CredentialsProvider = (url, usernameFromUrl, types) => credentials }; var repoPath = Repository.Clone(args.Url, gitDirectory, cloneOptions); var repository = new Repository(repoPath); var repoContext = new GitRepositoryContext(repository, credentials, true, args.Url, fileSystem); return repoContext; } }
public void Clone() { var co = new CloneOptions(); co.RecurseSubmodules = true; co.OnProgress = ProgressChanged; Repository.Clone("git://github.com/SirCmpwn/TrueCraft.git", TrueCraftDir, co); }
public static void Main(string[] args) { try { log("started..."); var repoUrl = args[0]; var branchName = "master"; var username = args[1]; var password = ""; if (args.Length == 3) { password = args[2]; } var pathSplit = repoUrl.Split('/'); var repoName = pathSplit.Last(); var author = new Signature("scarletapi", "@gmail", DateTime.Now); var repoDir = new DirectoryInfo(Path.Combine(Directory.GetCurrentDirectory(), repoName)); var repoPath = repoDir.FullName; if (String.IsNullOrEmpty(username)) { throw new Exception("Must have username"); } if (String.IsNullOrEmpty(password)) { repoUrl = repoUrl.Replace(pathSplit[2], String.Format("{0}@{2}", username, password, pathSplit[2])); } else { repoUrl = repoUrl.Replace(pathSplit[2], String.Format("{0}:{1}@{2}", username, password, pathSplit[2])); } log("checking if repo exists"); if (!repoDir.Exists || !Repository.IsValid(repoPath)) { if (repoDir.Exists) { repoDir.Delete(true); } var cloneOptions = new CloneOptions(); cloneOptions.BranchName = branchName; log("cloning {0} repository at url {1}", repoName, repoUrl); repoUrl = Repository.Clone(repoUrl, repoPath, cloneOptions); using (var repo = new LibGit2Sharp.Repository(repoPath)) { repo.Checkout(repo.Branches[branchName], new CheckoutOptions()); } } } catch (Exception e) { log("ERROR: {0}", e.Message); } }
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(); }
public static void Clone(string sourceUrl, string workingDir) { var cloneOptions = new CloneOptions(); cloneOptions.IsBare = false; cloneOptions.Checkout = true; cloneOptions.CredentialsProvider = new LibGit2Sharp.Handlers.CredentialsHandler((a, b, c) => new UsernamePasswordCredentials() { Username = ApplicationConfiguration.Get("pandora_git_username"), Password = ApplicationConfiguration.Get("pandora_git_password") }); Repository.Clone(sourceUrl, workingDir, cloneOptions); }
public override async Task<JobResult> Run() { var args = JobDescriptor.GetArgumentsJson<CloneJobArgs>(); var fullname = args.Url.Replace("https://github.com/", "") .Replace("http://github.com/", "") .Replace(".git", ""); var clonePathAbs = _codeLocationRepository.GetCodeLocationLocalPath(fullname); return await Task.Run(() => { var options = new CloneOptions() { BranchName = args.Branch, IsBare = args.Bare, Checkout = true, CredentialsProvider = (_url, _user, _cred) => new UsernamePasswordCredentials { Username = args.Username, Password = _apiRepository.GetUserToken(args.Username) } }; try { var result = _repositoryController.Clone(args.Url, clonePathAbs, options); // create an entry for the repository in our db, so we can link commits to it var codelocation = _codeLocationRepository.CreateCodeLocation(fullname, args.RepoName, args.Username); // let other workers know that this worker has this code location _codeLocationRepository.RecordCodeLocationOnWorker(WorkerId, codelocation.Id); // schedule an import _jobRepository.ScheduleJob<ImportHistoryJob>(codelocation); _jobRepository.CompleteJob(Id, WorkerId, new { localPath = result }); return Task.FromResult<JobResult>(new JobSuccessResult(this)); } catch (Exception e) { return Task.FromResult<JobResult>(new JobFailureResult(e, this)); } }); }
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); } } }
public async Task<string> Clone(string url, string workingDirectory, CloneOptions options = null) { return await new Task<string>(() => Repository.Clone(url, workingDirectory, options)); }
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); } }
public GitRepository(string url, string repoName, bool copyIfNotLocal = true, string branch = null, NetworkCredential credentials = null) { Url = url; RepositoryName = repoName; Branch = branch ?? "master"; Credentials = credentials; var localPath = Path.Combine(LocalRepositoryFolder, RepositoryName); IsLocal = Directory.Exists(localPath); CredentialsHandler = (_url, _user, _cred) => new UsernamePasswordCredentials() { Username = Credentials.UserName, Password = Credentials.Password }; if (!IsLocal && copyIfNotLocal) { var cloneOptions = new CloneOptions() { BranchName = Branch, IsBare = false, CredentialsProvider = CredentialsHandler }; var path = Repository.Clone(Url, Path.Combine(LocalRepositoryFolder, RepositoryName), cloneOptions); IsLocal = true; LinkRepo(); } else LinkRepo(); }
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 string RetrieveProject(string username, string password) { string baseRepositoryPath = Path.Combine(System.Web.Hosting.HostingEnvironment.MapPath("~/"),"GithubStaging"); _absoluteRepositoryPath = Path.Combine(baseRepositoryPath, UserName, RepoName); // libgit2 requires the target directory to be empty if (Directory.Exists(_absoluteRepositoryPath)) { DeleteReadOnlyDirectory(_absoluteRepositoryPath); } Directory.CreateDirectory(_absoluteRepositoryPath); //credentials provided if (!string.IsNullOrEmpty(username) || !string.IsNullOrEmpty(password)) { CloneOptions cloneOptions = new CloneOptions(); cloneOptions.CredentialsProvider = (url, fromUrl, types) => new UsernamePasswordCredentials() { Username = username, Password = password }; Repository.Clone(_url, _absoluteRepositoryPath, cloneOptions); } else { //no credentials Repository.Clone(_url, _absoluteRepositoryPath); } return _absoluteRepositoryPath; }
protected virtual bool Run() { var currentDirectory = Directory.GetCurrentDirectory(); var rootRepositoryDirectory = VersionResolver.GetRootRepositoryDirectoryOf(currentDirectory); Log($"{nameof(BaseGit)}.{nameof(Run)}: current directory = {currentDirectory}, root repository directory = {rootRepositoryDirectory}"); var rawDependencies = JsonConvert.DeserializeObject<CompileDependencies>(File.ReadAllText(DependencyFile)); var userDefinedDependencies = readUserDefinedDependencies(); var userDefinedAuthentication = readUserDefinedAuth(); var dependencies = MergeDependencies(rawDependencies, userDefinedDependencies, userDefinedAuthentication); Names = dependencies.Select(d => $@"{d.OutputFolder}\build.xml").ToArray(); try { IndentLevel++; using (var myRepository = new Repository(rootRepositoryDirectory.FullName)) { foreach (var dependency in dependencies) { if (dependency.UseGit) { var cloneOptions = new CloneOptions() { CredentialsProvider = (_url, _user, _cred) => dependency.GetCredentials(Authentication) }; if (dependency.Branch == "autoversioning") HandleAutoVersioning(myRepository, rawDependencies.ShortName, dependency, cloneOptions); else HandleFixedVersioning(dependency, cloneOptions); } else Log($"Dependency {dependency} does not use a remote repository"); } } } finally { IndentLevel--; } return true; }
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; }
protected virtual void HandleAutoVersioning(Repository myRepository, string myShortName, Dependency dependency, CloneOptions cloneOptions) { if (!string.IsNullOrEmpty(dependency.Commit)) throw new InvalidOperationException($"Dependency {dependency}: autoversioning: definition is incoherent: Branch = '{dependency.Branch}' and a Commit = '{dependency.Commit}' => you can't have both set!"); if (Directory.Exists(dependency.OutputFolder)) { Log($"Dependency {dependency}: autoversioning: output folder already exists: removing..."); new DirectoryInfo(dependency.OutputFolder).ForceDelete(); } Log($"Dependency {dependency}: autoversioning: cloning default branch of '{dependency.Remote}' into '{dependency.OutputFolder}'"); Repository.Clone(dependency.Remote, dependency.OutputFolder, cloneOptions); try { IndentLevel++; using (var otherRepository = new Repository(dependency.OutputFolder)) { otherRepository.CheckoutAllRemoteBranches(); VersionResolver.CheckoutBranchInDependencyRepository(otherRepository, myRepository, myShortName, this); } } finally { IndentLevel--; } }
public static DirectoryPath GitClone( this ICakeContext context, string sourceUrl, DirectoryPath workDirectoryPath, string username, string password ) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (string.IsNullOrWhiteSpace(sourceUrl)) { throw new ArgumentNullException(nameof(sourceUrl)); } if (string.IsNullOrWhiteSpace(username)) { throw new ArgumentNullException(nameof(username)); } if (string.IsNullOrWhiteSpace(password)) { throw new ArgumentNullException(nameof(password)); } if (workDirectoryPath == null) { throw new ArgumentNullException(nameof(workDirectoryPath)); } var workFullDirectoryPath = workDirectoryPath.MakeAbsolute(context.Environment); if (!context.FileSystem.Exist(workFullDirectoryPath)) { throw new DirectoryNotFoundException($"Failed to find workDirectoryPath: {workFullDirectoryPath}"); } var options = new CloneOptions { CredentialsProvider = (url, user, cred) => new UsernamePasswordCredentials {Username = username, Password = password} }; return Repository.Clone(sourceUrl, workFullDirectoryPath.FullPath, options); }
protected virtual void HandleFixedVersioning(Dependency dependency, CloneOptions cloneOptions) { if (!string.IsNullOrEmpty(dependency.Branch) && !string.IsNullOrEmpty(dependency.Commit)) throw new InvalidOperationException($"Dependency {dependency}: fixed versioning: definition is incoherent: Branch = '{dependency.Branch}' != '' and Commit = '{dependency.Commit}' != '' => you can't have both set!"); if (!Directory.Exists(dependency.OutputFolder)) { Log($"Dependency {dependency}: fixed versioning: cloning fixed branch '{dependency.Branch}' of '{dependency.Remote}' into '{dependency.OutputFolder}'..."); cloneOptions.BranchName = dependency.Branch; Repository.Clone(dependency.Remote, dependency.OutputFolder, cloneOptions); } else if (Pull) { Log($"Dependency {dependency}: fixed versioning: repository '{dependency.Remote}' already cloned in '{dependency.OutputFolder}'"); try { IndentLevel++; using (var otherRepository = new Repository(dependency.OutputFolder)) { otherRepository.CheckoutAllRemoteBranches(); if (!string.IsNullOrEmpty(dependency.Commit)) HandleFixedVersioning_Commit(dependency, otherRepository); else HandleFixedVersioning_Branch(dependency, otherRepository); } } finally { IndentLevel--; } } }
private void DownloadAddon() { bool updated = false; bool cloned = false; if (!Directory.Exists(info.packedPath)) { Directory.CreateDirectory(info.packedPath); } if (Directory.Exists(info.dlPath) && Repository.IsValid(info.dlPath)) { using (Repository repo = new Repository(info.dlPath)) { RepositoryStatus status = repo.RetrieveStatus(); string commit = repo.Head.Tip.Id.Sha; // reset local changes if (status.IsDirty) { repo.Reset(ResetMode.Hard); } // fetch & merge from origin repo.Network.Fetch(repo.Network.Remotes["origin"]); repo.MergeFetchedRefs(new Signature("meldii", "*****@*****.**", new DateTimeOffset()), new MergeOptions()); // updated if (!repo.Head.Tip.Id.Sha.Equals(commit)) { updated = true; } } } else { if (Directory.Exists(info.dlPath)) { ForceDeleteDirectory(info.dlPath); } CloneOptions co = new CloneOptions(); co.BranchName = info.branch; Repository.Clone(info.url, info.dlPath, co); updated = true; cloned = true; } //Pack & ship it if (updated) { if (File.Exists(info.packedFile)) { File.Delete(info.packedFile); } ZipFile zip = new ZipFile(info.packedFile); foreach (string file in Directory.EnumerateFiles(info.dlPath, "*.*", SearchOption.AllDirectories)) { string rPath = file.Replace(info.dlPath, "").TrimStart(new char[] { '\\', '/' }); if (!rPath.StartsWith(".git", StringComparison.CurrentCultureIgnoreCase) && !rPath.Equals("README.md", StringComparison.CurrentCultureIgnoreCase)) { string[] split = rPath.Split(new char[] { '\\', '/' }); string zipPath = split.Length == 1 ? "" : string.Join("\\", split, 0, split.Length - 1); zip.AddFile(file, zipPath); } } zip.Save(); } if (cloned) { _Copy(Path.Combine(MeldiiSettings.Self.AddonLibaryPath, info.repoName) + ".zip", info.packedFile); } }
private static void RunLibGit2SharpCode(TextWriter log) { // TODO: enter your VSTS alternate credentials string userName = ""; string password = ""; // TODO: enter your VSTS account name string accountRoot = "yourroot"; // TODO: enter the name of a clean VSTS team project // with an emptry default Git repo string teamProjectName = "yourteamproject"; try { var co = new CloneOptions(); co.CredentialsProvider = (_url, _user, _cred) => new UsernamePasswordCredentials { Username = userName, Password = password }; string reposRoot = Path.Combine( Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "repos"); if (Directory.Exists(reposRoot)) { // directory exists, delete log.WriteLine("Cleaning reposRoot: " + reposRoot); DeleteReadOnlyDirectory(reposRoot); } string repoRoot = Path.Combine(reposRoot, teamProjectName); string accountUrl = string.Format("https://{0}.visualstudio.com/DefaultCollection", accountRoot); Repository.Clone(accountUrl + "/_git/" + teamProjectName, repoRoot, co); log.WriteLine("Clone Done!"); using (Repository repo = new Repository(repoRoot)) { log.WriteLine("Repo aquired"); //// Write file string newFilePath = System.IO.Path.Combine(repoRoot, "test.txt"); System.IO.File.WriteAllText(newFilePath, "Some great text."); log.WriteLine("New text file written"); log.WriteLine("repo.RetrieveStatus()"); var status = repo.RetrieveStatus(); foreach (var item in status) { if (item.State == FileStatus.Untracked) { // *** Warning *** // this line of code causes the Azure Web Job to blow up repo.Index.Add(item.FilePath); log.WriteLine(item.FilePath + " added to index"); } } } } catch (Exception ex) { log.WriteLine("Failure in LoadCodeIntoGitRepo"); log.WriteLine(ex.ToString()); } }
private void CloneRepositories() { string repoDir = outputDir + @"\BitBucket Repositories\" + requestedAcct + @"\"; if (Directory.Exists(repoDir)) { DeleteFolderPath(repoDir); } var creds = new CloneOptions() { CredentialsProvider = (_url, _user, _pw) => new UsernamePasswordCredentials { Username = bbName, Password = bbPassword } }; foreach (string repo in repositories) { string url = @"https://bitbucket.org/" + requestedAcct + "/" + repo; string cloneDir = repoDir + repo; try { LibGit2Sharp.Repository.Clone(url, cloneDir, creds); } catch { string msg = "Handled LibGit2Sharp exception"; MessageBox.Show(msg); } } }