private async Task <GitRepository> CreateRepostory(CreateDotNetCoreRepositoryCommand request, CancellationToken cancellationToken)
{
var client = _vstsClient.GetClient();
GitRepositoryCreateOptions projectCreateParameters = new GitRepositoryCreateOptions {
Name = request.RepositoryName
};
var stringContent = _vstsClient.ConvertBody(projectCreateParameters);
var response = await client.PostAsync($"{request.Organization}/{request.Project}/_apis/git/repositories/?api-version=6.0-preview.1", stringContent, cancellationToken);
if (response.IsSuccessStatusCode)
{
var contents = await response.Content.ReadAsStringAsync();
var responseResult = JsonConvert.DeserializeObject
<GitRepository>(contents);
return(responseResult);
}
else
{
//log
return(null);
}
}
/// <summary>
/// Create new git repo
/// </summary>
/// <param name="TeamProjectName"></param>
/// <param name="GitNewRepoName"></param>
/// <param name="ParentRepo"></param>
private static void CreateGitRepo(string TeamProjectName, string GitNewRepoName, string ParentRepo = null)
{
GitRepository newRepo;
if (ParentRepo != null)
{
GitRepositoryCreateOptions newGitRepository = new GitRepositoryCreateOptions();
newGitRepository.Name = GitNewRepoName;
GitRepository parent = GitClient.GetRepositoryAsync(TeamProjectName, ParentRepo).Result;
newGitRepository.ParentRepository = new GitRepositoryRef();
newGitRepository.ParentRepository.Id = parent.Id;
newGitRepository.ParentRepository.ProjectReference = parent.ProjectReference;
newRepo = GitClient.CreateRepositoryAsync(newGitRepository, TeamProjectName, "refs/heads/master").Result;
}
else
{
newRepo = new GitRepository();
newRepo.Name = GitNewRepoName;
newRepo = GitClient.CreateRepositoryAsync(newRepo, TeamProjectName).Result;
}
Console.WriteLine("===============Created New Repo===============================");
PrintRepoInfo(newRepo);
Console.WriteLine("==============================================================");
}
public async Task <GitRepository> CreateRepository(string projectName, string repositoryName, bool initialise)
{
GitRepository repo = null;
try
{
GitRepositoryCreateOptions options = new GitRepositoryCreateOptions
{
Name = repositoryName
};
repo = await Git.CreateRepositoryAsync(options, projectName, null, null, default);
}
catch (Exception ex)
{
throw new Exception($"Failed to create new repository: {repositoryName}", ex);
}
if (initialise)
{
GitRefUpdate newBranch = new GitRefUpdate
{
Name = "refs/heads/master",
OldObjectId = new string('0', 40)
};
GitCommitRef newCommit = new GitCommitRef()
{
Comment = "Add a sample file",
Changes = new GitChange[]
{
new GitChange()
{
ChangeType = VersionControlChangeType.Add,
Item = new GitItem()
{
Path = "/readme.md"
},
NewContent = new ItemContent()
{
Content = "Empty file for initial commit",
ContentType = ItemContentType.RawText,
},
}
},
};
try
{
_ = await Git.CreatePushAsync(new GitPush()
{
RefUpdates = new GitRefUpdate[] { newBranch },
Commits = new GitCommitRef[] { newCommit },
}, repo.Id);
}
catch (Exception ex)
{
throw new Exception($"Could not initialise repository: {repositoryName}", ex);
}
}
return(repo);
}
static async Task Main(string[] args)
{
Uri org1Url = new Uri("https://dev.azure.com/" + Environment.GetEnvironmentVariable("ORG1"));
String project1 = Environment.GetEnvironmentVariable("PROJ1");
String pat1 = Environment.GetEnvironmentVariable("PAT1"); // See https://docs.microsoft.com/azure/devops/integrate/get-started/authentication/pats
Uri org2Url = new Uri("https://dev.azure.com/" + Environment.GetEnvironmentVariable("ORG2"));
String project2 = Environment.GetEnvironmentVariable("PROJ2");
String pat2 = Environment.GetEnvironmentVariable("PAT2");
// Project name which this should look at
Boolean dryRun = !String.IsNullOrEmpty(Environment.GetEnvironmentVariable("DRYRUN"));
// Create a connection
var sourceConnection = new VssConnection(org1Url, new VssBasicCredential(string.Empty, pat1));
var destinationConnection = new VssConnection(org2Url, new VssBasicCredential(string.Empty, pat2));
var destProject = await destinationConnection.GetClient <ProjectHttpClient>().GetProject(project2);
var sourceRepos = await GetAllRepos(sourceConnection, project1);
var destReposDict = (await GetAllRepos(destinationConnection, project2)).ToDictionary(x => x.Name);
var missingReposInDest = sourceRepos.Where(x => !destReposDict.ContainsKey(getDestNameFromSourceName(x.Name)));
var tempPath = Path.GetTempPath();
var tempDir = Directory.CreateDirectory(Path.Join(tempPath, "repocloner", RandomString(5).ToLower()));
Console.WriteLine($"Using path {tempDir.FullName}");
// Create any repos missing in proj2
var destSourceClient = destinationConnection.GetClient <GitHttpClient>();
foreach (var sourceRepo in missingReposInDest)
{
if (dryRun)
{
Console.WriteLine($"Would create repo {sourceRepo.Name} in {destSourceClient.BaseAddress}");
}
else
{
var gitToCreate = new GitRepositoryCreateOptions()
{
Name = getDestNameFromSourceName(sourceRepo.Name),
ProjectReference = destProject,
};
var destRepo = await destSourceClient.CreateRepositoryAsync(gitToCreate);
destReposDict[destRepo.Name] = destRepo;
}
}
// Sync source from proj1 to proj2 for all branchs
foreach (var sourceRepo in sourceRepos)
{
var destRepo = destReposDict[getDestNameFromSourceName(sourceRepo.Name)];
if (dryRun)
{
Console.WriteLine($"Would clone {sourceRepo.Name} @ {sourceRepo.WebUrl} and sync to {destRepo.Name} @ {destRepo.WebUrl}");
}
else
{
// Create a temp dir to store the cloned repo
var gitDir = Directory.CreateDirectory(Path.Join(tempDir.FullName, sourceRepo.Name));
var co = new CloneOptions();
CredentialsHandler sourceCredProvider = (_url, _user, _cred) => new UsernamePasswordCredentials {
Username = pat1, Password = pat1
};
co.CredentialsProvider = sourceCredProvider;
Console.WriteLine($"Cloning source {sourceRepo.Name}");
Repository.Clone(sourceRepo.RemoteUrl, gitDir.FullName, co);
using (var repo = new Repository(gitDir.FullName))
{
CredentialsHandler destCredProvider = (_url, _user, _cred) => new UsernamePasswordCredentials {
Username = pat2, Password = pat2
};
LibGit2Sharp.PushOptions options = new LibGit2Sharp.PushOptions();
options.CredentialsProvider = destCredProvider;
if (!repo.Network.Remotes.Where(x => x.Name == "dest").Any())
{
repo.Network.Remotes.Add("dest", destRepo.RemoteUrl);
}
else
{
repo.Network.Remotes.Remove("dest");
repo.Network.Remotes.Add("dest", destRepo.RemoteUrl);
}
var destRemote = repo.Network.Remotes["dest"];
foreach (var branch in repo.Branches)
{
Console.WriteLine($"Pusing source {sourceRepo.Name}:{branch} to {destRepo.Name}:{branch} @ {destRepo.Url}");
repo.Network.Push(destRemote, branch.CanonicalName, new PushOptions()
{
CredentialsProvider = destCredProvider
});
}
}
}
}
}
