public override void AfterApplyCommand(RepositoryInfo repository, Command command)
{
if (command.CommandName == CommandName.CreateGherkinLink)
{
GitGherkinLinkProvider.CreateGherkinLink(repository, command);
}
}
public VsPackageManagerFactory(ISolutionManager solutionManager,
IPackageRepositoryFactory repositoryFactory,
IFileSystemProvider fileSystemProvider,
IRepositorySettings repositorySettings,
IRecentPackageRepository recentPackagesRepository)
{
if (solutionManager == null) {
throw new ArgumentNullException("solutionManager");
}
if (repositoryFactory == null) {
throw new ArgumentNullException("repositoryFactory");
}
if (fileSystemProvider == null) {
throw new ArgumentNullException("fileSystemProvider");
}
if (repositorySettings == null) {
throw new ArgumentNullException("repositorySettings");
}
_fileSystemProvider = fileSystemProvider;
_repositorySettings = repositorySettings;
_solutionManager = solutionManager;
_repositoryFactory = repositoryFactory;
_recentPackageRepository = recentPackagesRepository;
_solutionManager.SolutionClosing += (sender, e) => {
_repositoryInfo = null;
};
}
public virtual void Fetch(RepositoryInfo repositoryInfo, string targetBranch)
{
// Sync with dropbox
DropboxInfo info = (DropboxInfo)repositoryInfo;
_helper.Sync(info.DeployInfo, targetBranch);
}
public bool TryGetRepositoryInfo(HttpRequest request, JObject payload, out RepositoryInfo repositoryInfo)
{
repositoryInfo = null;
if (!String.IsNullOrEmpty(payload.Value<string>("NewCursor")))
{
repositoryInfo = new DropboxInfo(payload);
}
return repositoryInfo != null;
}
public override void Create()
{
base.Create();
var repositoryManager = Container.Get<RepositoryManager>();
this.FakeSecurityContext.UserName = "******";
RepoPath = repositoryManager.GetPathFor(REPO_NAME);
var repositoryInfo = new RepositoryInfo(RepoPath, REPO_NAME);
RepositoryRoot = Path.Combine(AppRoot, repositoryInfo.Path);
DirectoryHelper.DeleteSubdirectories(RepositoryRoot.ParentDirectory());
if (!Directory.Exists(RepositoryRoot))
Directory.CreateDirectory(RepositoryRoot);
}
public VsPackageManagerFactory(ISolutionManager solutionManager,
IPackageRepositoryFactory repositoryFactory,
IVsPackageSourceProvider packageSourceProvider,
IFileSystemProvider fileSystemProvider,
IRepositorySettings repositorySettings,
IRecentPackageRepository recentPackagesRepository,
VsPackageInstallerEvents packageEvents,
IPackageRepository cacheRepository)
{
if (solutionManager == null)
{
throw new ArgumentNullException("solutionManager");
}
if (repositoryFactory == null)
{
throw new ArgumentNullException("repositoryFactory");
}
if (packageSourceProvider == null)
{
throw new ArgumentNullException("packageSourceProvider");
}
if (fileSystemProvider == null)
{
throw new ArgumentNullException("fileSystemProvider");
}
if (repositorySettings == null)
{
throw new ArgumentNullException("repositorySettings");
}
if (cacheRepository == null)
{
throw new ArgumentNullException("cacheRepository");
}
if (packageEvents == null)
{
throw new ArgumentNullException("packageEvents");
}
_fileSystemProvider = fileSystemProvider;
_repositorySettings = repositorySettings;
_solutionManager = solutionManager;
_repositoryFactory = repositoryFactory;
_recentPackageRepository = recentPackagesRepository;
_packageSourceProvider = packageSourceProvider;
_packageEvents = packageEvents;
_cacheRepository = cacheRepository;
_solutionManager.SolutionClosing += (sender, e) =>
{
_repositoryInfo = null;
};
}
private RepositoryInfo GetRepositoryInfo()
{
// Update the path if it needs updating
string path = _repositorySettings.RepositoryPath;
if (_repositoryInfo == null || !_repositoryInfo.Path.Equals(path)) {
IFileSystem fileSystem = _fileSystemProvider.GetFileSystem(path);
ISharedPackageRepository repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem);
_repositoryInfo = new RepositoryInfo(path, fileSystem, repository);
}
return _repositoryInfo;
}
public EmailManager()
{
try
{
ConfigHelper config = new ConfigHelper();
_repository = config.GetRepository("RestrictedSymbolList");
string serverName = ConfigurationManager.AppSettings["SMTPServer"];
_client = new SmtpClient(serverName);
}
catch (Exception ex)
{
throw new ApplicationException("SMTP Client Init Error: " + ex.Message);
}
}
static List <MountPendingMergeLink> BuildMountPendingMergeLinks(
MountPoint mount, IList <PendingMergeLink> links)
{
List <MountPendingMergeLink> result = new List <MountPendingMergeLink>();
RepositoryInfo repInfo = RepositorySpecResolverProvider.Get().
GetRepInfo(mount.RepSpec);
foreach (PendingMergeLink link in links)
{
result.Add(new MountPendingMergeLink(repInfo.GetRepSpec(), link));
}
return(result);
}
public void SetUp()
{
this.telemetryClient = TelemetryMock.InitializeMockTelemetryClient();
MongoClient client = new MongoClient(Settings.ConnectionString);
client.DropDatabase(Settings.DatabaseName);
RepositoryDatabase database = new RepositoryDatabase(Settings);
RepositoryInfo result = database.Create(this.testRepoOne);
Assert.IsNotNull(result);
RepositoryInfo result2 = database.Create(this.testRepoTwo);
Assert.IsNotNull(result2);
}
public void on_a_non_tagged_repository_all_commits_can_be_a_first_possible_version()
{
var repoTest = TestHelper.TestGitRepository;
foreach (SimpleCommit c in repoTest.Commits)
{
RepositoryInfo i = repoTest.GetRepositoryInfo(c.Sha);
Assert.That(i.RepositoryError, Is.Null);
Assert.That(i.ReleaseTagErrorLines, Is.Null);
Assert.That(i.ValidReleaseTag, Is.Null);
Assert.That(i.PreviousRelease, Is.Null);
Assert.That(i.PreviousMaxRelease, Is.Null);
CollectionAssert.AreEqual(ReleaseTagVersion.FirstPossibleVersions, i.PossibleVersions);
}
}
private void PerformDeployment(RepositoryInfo repositoryInfo, string targetBranch)
{
if (repositoryInfo.UseSSH)
{
using (_tracer.Step("Prepare SSH environment"))
{
_gitServer.SetSSHEnv(repositoryInfo.Host, _environment.ApplicationRootPath);
}
}
bool hasPendingDeployment;
do
{
hasPendingDeployment = false;
using (_tracer.Step("Performing fetch based deployment"))
{
// Configure the repository
_gitServer.Initialize(_configuration);
// Setup the receive info (this is important to know if branches were deleted etc)
_gitServer.SetReceiveInfo(repositoryInfo.OldRef, repositoryInfo.NewRef, targetBranch);
// Fetch from url
_gitServer.FetchWithoutConflict(repositoryInfo.RepositoryUrl, "external", targetBranch);
// Perform the actual deployment
_deploymentManager.Deploy(repositoryInfo.Deployer);
if (MarkerFileExists())
{
_tracer.Trace("Pending deployment marker file exists");
hasPendingDeployment = DeleteMarkerFile();
if (hasPendingDeployment)
{
_tracer.Trace("Deleted marker file");
}
else
{
_tracer.TraceError("Failed to delete marker file");
}
}
}
} while (hasPendingDeployment);
}
public void RepositoryAssign()
{
RepositoryInfo ri = new RepositoryInfo
{
Proprietary = "Guionardo"
};
Console.WriteLine(ri);
RepositoryInfo r2 = new RepositoryInfo();
Console.WriteLine(r2);
Console.WriteLine("Assign");
r2.Assign(ri);
Console.WriteLine(r2);
}
internal async Task <bool> CanSynchronize(RepositoryInfo targetRepository, SyncOutput expectedOutput)
{
if (expectedOutput == SyncOutput.CreatePullRequest ||
expectedOutput == SyncOutput.MergePullRequest)
{
var hasOpenPullRequests = await gateway.HasOpenPullRequests(targetRepository.Owner, targetRepository.Repository, PullRequestTitle);
if (hasOpenPullRequests)
{
log("Cannot create pull request, there is an existing open pull request, close or merge that first");
return(false);
}
}
return(true);
}
private bool TryGetRepositoryInfo(IExecutionContext executionContext, out RepositoryInfo repoInfo)
{
// Return the matching repository resource and its source provider.
Trace.Entering();
var primaryRepo = RepositoryUtil.GetPrimaryRepository(executionContext.Repositories);
var triggeringRepo = RepositoryUtil.GetTriggeringRepository(executionContext.Repositories);
repoInfo = new RepositoryInfo
{
PrimaryRepository = primaryRepo,
TriggeringRepository = triggeringRepo,
SourceProvider = GetSourceProvider(executionContext, primaryRepo),
};
return(repoInfo.SourceProvider != null);
}
public void SetUp()
{
MongoClient client = new MongoClient(Settings.ConnectionString);
client.DropDatabase(Settings.DatabaseName);
RepositoryDatabase database = new RepositoryDatabase(Settings);
RepositoryInfo result = database.Create(this.snapshotRepoOne);
Assert.IsNotNull(result);
RepositoryInfo result2 = database.Create(this.snapshotRepoTwo);
Assert.IsNotNull(result2);
RepositoryInfo result3 = database.Create(this.defaultRepoOne);
Assert.IsNotNull(result3);
}
private RepositoryInfo CreateRepositoryInfo(string repoName, string repoStoragePath)
{
var currentHeadRevision = _svnLookProvider.GetHeadRevision(repoStoragePath);
var latestChangeTimestamp = _svnLookProvider.GetRevisionTimestamp(repoStoragePath, currentHeadRevision);
var repoInfo = new RepositoryInfo
{
Name = repoName,
LatestRevision = currentHeadRevision,
LatestChangeTimestamp = latestChangeTimestamp,
LatestChangeUsername = _svnLookProvider.GetRevisionUsername(repoStoragePath, currentHeadRevision),
SizeInBytes = GetRepoSizeInBytes(repoStoragePath),
Url = _serverInfoProvider.BaseRepoUrl + repoName,
};
return(repoInfo);
}
public void UpdatesExistingDynamicRepository()
{
var repoName = Guid.NewGuid().ToString();
var tempPath = Path.GetTempPath();
var tempDir = Path.Combine(tempPath, repoName);
Directory.CreateDirectory(tempDir);
string dynamicRepositoryPath = null;
try
{
using (var mainRepositoryFixture = new EmptyRepositoryFixture())
{
mainRepositoryFixture.Repository.MakeCommits(1);
var repositoryInfo = new RepositoryInfo
{
Url = mainRepositoryFixture.RepositoryPath,
Branch = "master"
};
using (var gitRepository = GitRepositoryFactory.CreateRepository(repositoryInfo))
{
dynamicRepositoryPath = gitRepository.DotGitDirectory;
}
var newCommit = mainRepositoryFixture.Repository.MakeACommit();
using (var gitRepository = GitRepositoryFactory.CreateRepository(repositoryInfo))
{
mainRepositoryFixture.Repository.DumpGraph();
gitRepository.Repository.DumpGraph();
gitRepository.Repository.Commits.ShouldContain(c => c.Sha == newCommit.Sha);
}
}
}
finally
{
Directory.Delete(tempDir, true);
if (dynamicRepositoryPath != null)
{
DeleteHelper.DeleteGitRepository(dynamicRepositoryPath);
}
}
}
public void NetCoreProject_Load()
{
var path = TestUtils.GetSampleProject(@"RepoCat.TestApps.NetCore.csproj");
var repo = new RepositoryInfo()
{
RepositoryName = "Test",
OrganizationName = "TestOrg"
};
var provider = ProjectInfoBuilderFactory.Get(new TransmitterArguments()
{
TransmissionMode = TransmissionMode.LocalDotNetProjects, RepositoryName = repo.RepositoryName, OrganizationName = repo.OrganizationName
}, new Mock <ILogger>().Object);
var info = (provider as ProjectInfoBuilderBase).GetInfo(path.FullName);
info.Should().NotBeNull();
info.RepositoryInfo.Should().BeEquivalentTo(repo);
info.Owner.Should().BeEquivalentTo("Jim The Beam");
info.ProjectDescription.Should().BeEquivalentTo("Description is optional");
info.ProjectName.Should().BeEquivalentTo("RepoCat.TestApps.NetCore");
info.RepositoryStamp.Should().NotBeNullOrEmpty();
info.AssemblyName.Should().Be("RepoCat.TestApps.NetCore");
info.Tags.Should().BeEquivalentTo(new[] { "These", "Tags", "Are", "Optional" });
info.Properties.Should().ContainEquivalentOf(new Property("EntireProjectProperties", "AreAlsoOptional"));
info.Properties.Should()
.ContainEquivalentOf(new Property("CodeFiles", new List <string>()
{
"Program.cs"
}));
info.Properties.Should()
.ContainEquivalentOf(new Property("ManualCollection", new List <string>()
{
"Value 1", "Val2", "V3"
}));
info.Components.Single().Name.Should().Be("SampleNetCoreConsoleApp");
info.Components.Single().Tags.Count.Should().Be(3);
info.Components.First().Properties.Should()
.ContainEquivalentOf(new Property("ComponentManualCollection", new List <string>()
{
"Value 1", "Val2", "V3"
}));
}
public VsPackageManagerFactory(ISolutionManager solutionManager,
IPackageRepositoryFactory repositoryFactory,
IVsPackageSourceProvider packageSourceProvider,
IFileSystemProvider fileSystemProvider,
IRepositorySettings repositorySettings,
IRecentPackageRepository recentPackagesRepository,
VsPackageInstallerEvents packageEvents)
{
if (solutionManager == null)
{
throw new ArgumentNullException("solutionManager");
}
if (repositoryFactory == null)
{
throw new ArgumentNullException("repositoryFactory");
}
if (packageSourceProvider == null)
{
throw new ArgumentNullException("packageSourceProvider");
}
if (fileSystemProvider == null)
{
throw new ArgumentNullException("fileSystemProvider");
}
if (repositorySettings == null)
{
throw new ArgumentNullException("repositorySettings");
}
if (packageEvents == null)
{
throw new ArgumentNullException("packageEvents");
}
_fileSystemProvider = fileSystemProvider;
_repositorySettings = repositorySettings;
_solutionManager = solutionManager;
_repositoryFactory = repositoryFactory;
_recentPackageRepository = recentPackagesRepository;
_packageSourceProvider = packageSourceProvider;
_packageEvents = packageEvents;
_solutionManager.SolutionClosing += (sender, e) =>
{
_repositoryInfo = null;
};
}
public RepositoryInfo GetRepositoryInfo(string basePath, string repositoryName)
{
var uri = this.GetUrl(basePath, repositoryName);
var latestLog = SvnLogInfo.GetLatestLog($"{uri}");
var firstLog = SvnLogInfo.GetFirstLog($"{uri}");
var repositoryInfo = new RepositoryInfo()
{
ID = GuidUtility.FromName(repositoryName + firstLog.Revision),
Name = repositoryName,
Comment = firstLog.Comment,
Revision = latestLog.Revision,
CreationInfo = new SignatureDate(firstLog.Author, firstLog.DateTime),
ModificationInfo = new SignatureDate(latestLog.Author, latestLog.DateTime),
};
return(repositoryInfo);
}
public async Task SnapshotModeSetFromStart()
{
RepositoryDatabase service = new RepositoryDatabase(Settings);
string organizationOne = MethodBase.GetCurrentMethod().Name;
string repoOne = Guid.NewGuid().ToString();
//add a new repository with snapshot mode
RepositoryInfo repo = await service.UpsertUpdate(
new RepositoryInfo()
{
OrganizationName = organizationOne,
RepositoryName = repoOne,
RepositoryMode = RepositoryMode.Snapshot
}).ConfigureAwait(false);
repo.RepositoryMode.Should().Be(RepositoryMode.Snapshot);
}
internal void CreateGherkinLink(RepositoryInfo repositoryInfo, Command command)
{
var args = (AppendToCollectionCommandArgs)command.CommandArgs;
var gherkinFile = (GherkinFile)entityRepository.Load(repositoryInfo, args.CollectionMember);
if (gherkinFile.FileProviderType != ProviderType)
return; // this is not for us
var updateBoundary = new Boundary(Context.Current);
try
{
GherkinFilePoller.TriggerUpdate(gherkinFile, updateBoundary);
}
catch (Exception ex)
{
logger.Log(TraceEventType.Error, "An exception has occurred during updating a gherkin file link: {0}", ex);
}
}
public Task <bool> TryDetectRepositoryInformationAsync(
string repositoryFolder,
string repositoryUri,
CancellationToken cancellationToken,
out RepositoryInfo?repositoryInfo)
{
if (!TryParseGitUri(repositoryUri, out IDictionary <string, string>?properties) ||
properties == null)
{
repositoryInfo = null;
return(Task.FromResult(false));
}
cancellationToken.ThrowIfCancellationRequested();
repositoryInfo = new RepositoryInfo(repositoryUri, properties, this);
return(Task.FromResult(true));
}
static IList <Guid> GetCandidatesGuids(
WorkspaceInfo wkInfo,
RepositorySpec repSpec,
List <WorkspaceTreeNode> candidates)
{
RepositoryInfo repInfo = RepositorySpecResolverProvider.
Get().GetRepInfo(repSpec);
IList <long> ids = new List <long>(candidates.Count);
foreach (WorkspaceTreeNode candidate in candidates)
{
ids.Add(candidate.RevInfo.ItemId);
}
return(GuidResolver.Get().GetObjectGuids(repInfo, wkInfo, ids));
}
public IVsPackageManager CreatePackageManager(IPackageRepository repository, bool useFallbackForDependencies)
{
RepositoryInfo info = GetRepositoryInfo();
var packageManager = new VsPackageManager(_solutionManager,
repository,
_fileSystemProvider,
info.FileSystem,
info.Repository,
// We ensure DeleteOnRestartManager is initialized with a PhysicalFileSystem so the
// .deleteme marker files that get created don't get checked into version control
new DeleteOnRestartManager(() => new PhysicalFileSystem(info.FileSystem.Root)),
_packageEvents,
_frameworkMultiTargeting);
packageManager.DependencyVersion = GetDependencyVersion();
return(packageManager);
}
/// <summary>
/// Gets the simple git version <see cref="RepositoryInfo"/> from a branch.
/// Returns null if an error occurred or if RepositoryInfo.xml has not been successfully read.
/// </summary>
/// <param name="m">The monitor to use.</param>
/// <param name="branchName">Defaults to <see cref="CurrentBranchName"/>.</param>
/// <returns>The RepositoryInfo or null if it it cannot be obtained.</returns>
public RepositoryInfo ReadRepositoryVersionInfo(IActivityMonitor m, string branchName = null)
{
if (branchName == null)
{
branchName = CurrentBranchName;
}
try
{
Branch b = Git.Branches[branchName];
if (b == null)
{
m.Error($"Unknown branch {branchName}.");
return(null);
}
var pathOpt = b.IsRemote
? SubPath.AppendPart("remotes").Combine(b.FriendlyName)
: SubPath.AppendPart("branches").AppendPart(branchName);
pathOpt = pathOpt.AppendPart("RepositoryInfo.xml");
var fOpt = FileSystem.GetFileInfo(pathOpt);
if (!fOpt.Exists)
{
m.Error($"Missing required {pathOpt} file.");
return(null);
}
var opt = RepositoryInfoOptions.Read(fOpt.ReadAsXDocument().Root);
opt.StartingBranchName = branchName;
var result = new RepositoryInfo(Git, opt);
if (result.RepositoryError != null)
{
m.Error($"Unable to read RepositoryInfo. RepositoryError: {result.RepositoryError}.");
return(null);
}
if (result.Error != null)
{
m.Error(result.ReleaseTagError);
return(null);
}
return(result);
}
catch (Exception ex)
{
m.Fatal($"While reading version info for branch '{branchName}'.", ex);
return(null);
}
}
public void PicksAnotherDirectoryNameWhenDynamicRepoFolderTaken()
{
var repoName = Guid.NewGuid().ToString();
var tempPath = Path.GetTempPath();
var tempDir = Path.Combine(tempPath, repoName);
Directory.CreateDirectory(tempDir);
string expectedDynamicRepoLocation = null;
try
{
using (var fixture = new EmptyRepositoryFixture())
{
fixture.Repository.CreateFileAndCommit("TestFile.txt");
File.Copy(Path.Combine(fixture.RepositoryPath, "TestFile.txt"), Path.Combine(tempDir, "TestFile.txt"));
expectedDynamicRepoLocation = Path.Combine(tempPath, fixture.RepositoryPath.Split(Path.DirectorySeparatorChar).Last());
Directory.CreateDirectory(expectedDynamicRepoLocation);
var repositoryInfo = new RepositoryInfo
{
Url = fixture.RepositoryPath,
Branch = "master"
};
using (var gitRepository = GitRepositoryFactory.CreateRepository(repositoryInfo))
{
gitRepository.IsDynamic.ShouldBe(true);
gitRepository.DotGitDirectory.ShouldBe(Path.Combine(expectedDynamicRepoLocation + "_1", ".git"));
}
}
}
finally
{
DeleteHelper.DeleteDirectory(tempDir, true);
if (expectedDynamicRepoLocation != null)
{
DeleteHelper.DeleteDirectory(expectedDynamicRepoLocation, true);
}
if (expectedDynamicRepoLocation != null)
{
DeleteHelper.DeleteGitRepository(expectedDynamicRepoLocation + "_1");
}
}
}
public RepositoryInfo RepositoryInfoDemo()
{
OperationOptions operationOptions = new OperationOptions();
RepositoryInfo repositoryInfo = schemaService.GetRepositoryInfo(DefaultRepository,
operationOptions);
Console.WriteLine(repositoryInfo.Name);
Console.WriteLine("Default schema name: " + repositoryInfo.DefaultSchemaName);
Console.WriteLine("Label: " + repositoryInfo.Label);
Console.WriteLine("Description: " + repositoryInfo.Description);
Console.WriteLine("Schema names:");
List<String> schemaList = repositoryInfo.SchemaNames;
foreach (String schemaName in schemaList)
{
Console.WriteLine(schemaName);
}
return repositoryInfo;
}
/// <summary>
///
/// </summary>
/// <param name="repository"></param>
/// <returns></returns>
public async Task <DownloadStatistics> GetDownloadStatistics(RepositoryInfo repository)
{
void CheckParams()
{
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
}
CheckParams();
FilterDefinition <DownloadStatistics> repositoryFilter =
RepoCatFilterBuilder.BuildStatisticsRepositoryFilter(repository.Id);
return(await this.FindOneOrCreateNewAsync(repository.Id, repositoryFilter));
}
public override ValidationResult Validate(RepositoryInfo repositoryInfo, Action <ValidationResult> notify = null)
{
var result = new ValidationResult(this);
var exist = FileSystemHelper.GetFolders(repositoryInfo.RepositoryRootPath, RelativePath).Any();
string message;
if (!exist && CheckType == CheckType.MustExist || exist && CheckType == CheckType.MustNotExist)
{
message = string.Format("Folder '{0}' {1}.", RelativePath, exist ? Resources.FolderRule_Validate_exists_This_folder_should_not_exist
: Resources.FolderRule_Validate_does_not_exist_This_folder_must_exist);
result.AddResult(ResultLevel.NotPassed, message);
return(result);
}
message = string.Format("Folder '{0}' {1}.", RelativePath, exist ? Resources.FolderRule_Validate_exists : Resources.FolderRule_Validate_does_not_exist);
result.AddResult(ResultLevel.Passed, message);
return(result);
}
/// <summary>
/// Gets the coollection of stamps for a given repository
/// </summary>
/// <param name="repository"></param>
/// <returns></returns>
public async Task <List <string> > GetStamps(RepositoryInfo repository)
{
void CheckParams()
{
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
}
CheckParams();
FilterDefinition <ProjectInfo> filter = Builders <ProjectInfo> .Filter.Eq(p => p.RepositoryId, repository.Id);
List <string> stamps = await(await this.projects.DistinctAsync(x => x.RepositoryStamp, filter).ConfigureAwait(false)).ToListAsync().ConfigureAwait(false);
return(stamps);
}
public IVsPackageManager CreatePackageManager(IPackageRepository repository, bool useFallbackForDependencies)
{
if (useFallbackForDependencies)
{
repository = CreateFallbackRepository(repository);
}
RepositoryInfo info = GetRepositoryInfo();
return(new VsPackageManager(_solutionManager,
repository,
_fileSystemProvider,
info.FileSystem,
info.Repository,
// We ensure DeleteOnRestartManager is initialized with a PhysicalFileSystem so the
// .deleteme marker files that get created don't get checked into version control
new DeleteOnRestartManager(() => new PhysicalFileSystem(info.FileSystem.Root)),
_packageEvents));
}
public void UpdatesExistingDynamicRepository()
{
var repoName = Guid.NewGuid().ToString();
var tempPath = Path.GetTempPath();
var tempDir = Path.Combine(tempPath, repoName);
Directory.CreateDirectory(tempDir);
string dynamicRepositoryPath = null;
try
{
using (var mainRepositoryFixture = new EmptyRepositoryFixture())
{
var commit = mainRepositoryFixture.Repository.MakeACommit();
var repositoryInfo = new RepositoryInfo
{
Url = mainRepositoryFixture.RepositoryPath
};
using (var dynamicRepository = DynamicRepositories.CreateOrOpen(repositoryInfo, tempPath, "master", commit.Sha))
{
dynamicRepositoryPath = dynamicRepository.Repository.Info.Path;
}
var newCommit = mainRepositoryFixture.Repository.MakeACommit();
using (var dynamicRepository = DynamicRepositories.CreateOrOpen(repositoryInfo, tempPath, "master", newCommit.Sha))
{
dynamicRepository.Repository.Info.Path.ShouldBe(dynamicRepositoryPath);
dynamicRepository.Repository.Commits.ShouldContain(c => c.Sha == newCommit.Sha);
}
}
}
finally
{
Directory.Delete(tempDir, true);
if (dynamicRepositoryPath != null)
{
DeleteHelper.DeleteGitRepository(dynamicRepositoryPath);
}
}
}
public IVsPackageManager CreatePackageManager(IPackageRepository repository, bool useFallbackForDependencies, bool addToRecent)
{
if (useFallbackForDependencies)
{
repository = CreateFallbackRepository(repository);
}
RepositoryInfo info = GetRepositoryInfo();
return(new VsPackageManager(_solutionManager,
repository,
_fileSystemProvider,
info.FileSystem,
info.Repository,
_recentPackageRepository,
_packageEvents)
{
AddToRecent = addToRecent
});
}
public void id_should_return_false_when_compared_with_null_and_empty_strings()
{
// Arrange
var info = new RepositoryInfo("", "");
RepositoryInfo nullInfo = null;
// Act + Assert
Assert.True(nullInfo == null);
Assert.False(info == null);
Assert.False(null == info);
Assert.False(info == "");
Assert.False("" == info);
Assert.True(info != null);
Assert.True(null != info);
Assert.True(info != "");
Assert.True("" != info);
}
public async Task <RepositoryStats> GetByRepositoryPathAsync(string path, string branch = "master")
{
if (path == null)
{
throw new ArgumentNullException(nameof(path), $"The {nameof(path)} parameter can not be null.");
}
if (branch == null)
{
throw new ArgumentNullException(nameof(branch), $"The {nameof(branch)} parameter can not be null.");
}
var cacheKey = $"{MethodBase.GetCurrentMethod().ReflectedType.GUID}_{path}";
RepositoryInfo repositoryInfoGH = _memoryCache.Get <RepositoryInfo>(cacheKey);
if (repositoryInfoGH != null)
{
_httpClient.DefaultRequestHeaders.IfNoneMatch.Add(repositoryInfoGH.ETag);
}
HttpResponseMessage httpResponseMessage = await _httpClient.GetAsync(string.Format(_gitHubRepositoryZipFileUriPattern, path, branch));
if (httpResponseMessage.StatusCode.Equals(HttpStatusCode.OK))
{
var filesInfoGH = await GetAsync(httpResponseMessage);
RepositoryStats repositoryStats = MapTo(filesInfoGH);
repositoryInfoGH = new RepositoryInfo
{
ETag = httpResponseMessage.Headers.ETag,
RepositoryStats = repositoryStats
};
_memoryCache.Set(cacheKey, repositoryInfoGH);
}
else if (!httpResponseMessage.StatusCode.Equals(HttpStatusCode.NotModified))
{
throw new RepositoryException("GitHub Repository not found.");
}
return(repositoryInfoGH.RepositoryStats);
}
// Custom Whitebox sorry...
//public dynamic UnitTestPeek
//{
// get
// {
// dynamic result = new ExpandoObject();
// return result;
// }
//}
public override ValidationResult Validate(RepositoryInfo repositoryInfo, Action <ValidationResult> notify = null)
{
var result = new ValidationResult(this);
var projectFilePaths = _projectFileHelper.GetAllProjectFilePath(repositoryInfo.RepositoryRootPath);
foreach (var projectFilePath in projectFilePaths)
{
try
{
_projectFileHelper.LoadProject(projectFilePath);
DoValidation(result, repositoryInfo, notify);
}
catch (Exception ex)
{
Logger.Error(ex);
}
}
return(result);
}
public async Task <RepositoryInfo> UpsertUpdate(RepositoryInfo repositoryInfo)
{
void CheckArgs()
{
if (repositoryInfo == null)
{
throw new ArgumentNullException(nameof(repositoryInfo));
}
}
CheckArgs();
FilterDefinition <RepositoryInfo> repoNameFilter =
Builders <RepositoryInfo> .Filter.Where(x =>
x.RepositoryName.ToUpperInvariant() == repositoryInfo.RepositoryName.ToUpperInvariant() &&
x.OrganizationName.ToUpperInvariant() == repositoryInfo.OrganizationName.ToUpperInvariant()
);
FindOneAndUpdateOptions <RepositoryInfo, RepositoryInfo> options = new FindOneAndUpdateOptions <RepositoryInfo, RepositoryInfo>()
{
IsUpsert = true,
ReturnDocument = ReturnDocument.After
};
UpdateDefinition <RepositoryInfo> updateDef = new UpdateDefinitionBuilder <RepositoryInfo>()
.SetOnInsert(x => x.OrganizationName, repositoryInfo.OrganizationName)
.SetOnInsert(x => x.RepositoryName, repositoryInfo.RepositoryName)
.SetOnInsert(x => x.RepositoryMode, repositoryInfo.RepositoryMode)
;
try
{
return(await this.repositories.FindOneAndUpdateAsync(repoNameFilter, updateDef, options)
.ConfigureAwait(false));
}
catch (MongoException)
{
//upsert might require a retry
//https://docs.mongodb.com/manual/reference/method/db.collection.findAndModify/#upsert-and-unique-index
//https://stackoverflow.com/questions/42752646/async-update-or-insert-mongodb-documents-using-net-driver
return(await this.repositories.FindOneAndUpdateAsync(repoNameFilter, updateDef, options)
.ConfigureAwait(false));
}
}
private RepositoryInfo GetRepositoryInfo()
{
// Update the path if it needs updating
string path = _repositorySettings.RepositoryPath;
string configFolderPath = _repositorySettings.ConfigFolderPath;
if (_repositoryInfo == null ||
!_repositoryInfo.Path.Equals(path, StringComparison.OrdinalIgnoreCase) ||
!_repositoryInfo.ConfigFolderPath.Equals(configFolderPath, StringComparison.OrdinalIgnoreCase) ||
_solutionManager.IsSourceControlBound != _repositoryInfo.IsSourceControlBound)
{
IFileSystem fileSystem = _fileSystemProvider.GetFileSystem(path);
IFileSystem configSettingsFileSystem = GetConfigSettingsFileSystem(configFolderPath);
// this file system is used to access the repositories.config file. We want to use Source Control-bound
// file system to access it even if the 'disableSourceControlIntegration' setting is set.
IFileSystem storeFileSystem = _fileSystemProvider.GetFileSystem(path, ignoreSourceControlSetting: true);
ISharedPackageRepository repository = new SharedPackageRepository(
new DefaultPackagePathResolver(fileSystem),
fileSystem,
storeFileSystem,
configSettingsFileSystem);
var settings = Settings.LoadDefaultSettings(
configSettingsFileSystem,
configFileName: null,
machineWideSettings: _machineWideSettings);
repository.PackageSaveMode = CalculatePackageSaveMode(settings);
_repositoryInfo = new RepositoryInfo(path, configFolderPath, fileSystem, repository);
}
return _repositoryInfo;
}
public override void AfterUndoCommand(RepositoryInfo repository, Command command) { /* SKIP */ }
private void Update(string referenceBranchName)
{
using (var repository = new Repository(RepositoryPath))
{
Branch referenceBranch = repository.Branches[referenceBranchName];
Branch currentBranch = repository.Branches.Current();
Commit latestMergeCommit = currentBranch.LatestMergeCommit(referenceBranch);
IEnumerable<TreeEntryChanges> changes = null;
if (latestMergeCommit != null)
{
changes = repository.Diff.Compare<TreeChanges>(latestMergeCommit.Tree, currentBranch.Tip.Tree)
.OrderBy(tc => tc.Path);
}
var repositoryInfo = new RepositoryInfo(
RepositoryPath,
repository.Branches.Select(b => b.Name).ToList(),
currentBranch.Name,
referenceBranch.Name,
latestMergeCommit == null ? null : latestMergeCommit.Sha,
changes);
DataContext = repositoryInfo;
}
}
private RepositoryInfo GetRepositoryInfo(HttpRequest request, string json)
{
JObject payload = null;
try
{
payload = JObject.Parse(json);
}
catch (Exception ex)
{
throw new FormatException(Resources.Error_UnsupportedFormat, ex);
}
var info = new RepositoryInfo();
// If it has a repository, then try to get information from that
var repository = payload.Value<JObject>("repository");
if (repository != null)
{
// Try to assume the github format
// { repository: { url: "" }, ref: "", before: "", after: "" }
info.RepositoryUrl = repository.Value<string>("url");
// The format of ref is refs/something/something else
// For master it's normally refs/head/master
string @ref = payload.Value<string>("ref");
if (String.IsNullOrEmpty(@ref))
{
throw new FormatException(Resources.Error_UnsupportedFormat);
}
// Just get the last token
info.Branch = @ref.Split('/').Last();
info.Deployer = GetDeployer(request);
info.OldRef = payload.Value<string>("before");
info.NewRef = payload.Value<string>("after");
}
else
{
// Look for the generic format
// { url: "", branch: "", deployer: "", oldRef: "", newRef: "" }
info.RepositoryUrl = payload.Value<string>("url");
info.Branch = payload.Value<string>("branch");
info.Deployer = payload.Value<string>("deployer");
info.OldRef = payload.Value<string>("oldRef");
info.NewRef = payload.Value<string>("newRef");
}
// If there's no specified branch assume master
if (String.IsNullOrEmpty(info.Branch))
{
info.Branch = "master";
}
if (String.IsNullOrEmpty(info.RepositoryUrl))
{
throw new FormatException(Resources.Error_MissingRepositoryUrl);
}
return info;
}
private void PrependRecentProjectsMenuItem(RepositoryInfo projectInfo) {
ToolStripItem item = new ToolStripMenuItem(projectInfo.projectName);
item.Tag = projectInfo;
item.ToolTipText = string.Format("Project: {0}{3}Location: {1}{3}Repository Type: {2}", projectInfo.projectName, projectInfo.location, projectInfo.typeName, Environment.NewLine);
item.Click += openRecentProjectMenuItem_Click;
recentProjectsMenuItem.DropDownItems.Insert(0, item);
if (!recentProjectsMenuItem.Visible) recentProjectsMenuItem.Visible = true;
}
public override void BeforeApplyCommand(RepositoryInfo repository, Command command) { /* SKIP */ }
private void PerformDeployment(RepositoryInfo repositoryInfo, string targetBranch)
{
if (repositoryInfo.UseSSH)
{
using (_tracer.Step("Prepare SSH environment"))
{
_gitServer.SetSSHEnv(repositoryInfo.Host, _environment.ApplicationRootPath);
}
}
bool hasPendingDeployment;
do
{
hasPendingDeployment = false;
using (_tracer.Step("Performing fetch based deployment"))
{
// Configure the repository
_gitServer.Initialize(_configuration);
// Setup the receive info (this is important to know if branches were deleted etc)
_gitServer.SetReceiveInfo(repositoryInfo.OldRef, repositoryInfo.NewRef, targetBranch);
// Fetch from url
_gitServer.FetchWithoutConflict(repositoryInfo.RepositoryUrl, "external", targetBranch);
// Perform the actual deployment
_deploymentManager.Deploy(repositoryInfo.Deployer);
if (MarkerFileExists())
{
_tracer.Trace("Pending deployment marker file exists");
hasPendingDeployment = DeleteMarkerFile();
if (hasPendingDeployment)
{
_tracer.Trace("Deleted marker file");
}
else
{
_tracer.TraceError("Failed to delete marker file");
}
}
}
} while (hasPendingDeployment);
}
private bool AddToRecentProjects(RepositoryInfo projectInfo) {
// Check if the project already exists in the recent projects list
for (int i = recentProjects.Count - 1; i >= 0; --i)
if (recentProjects[i] == projectInfo) return false;
// If it does not, add it and create a new menu item
if (recentProjects.Count == recentProjectsItemCount)
recentProjects.RemoveAt(0);
recentProjects.Add(projectInfo);
PrependRecentProjectsMenuItem(projectInfo);
SaveConfigFile();
return true;
}
private RepositoryInfo GetRepositoryInfo(HttpRequest request, string json)
{
JObject payload = null;
try
{
payload = JObject.Parse(json);
}
catch (Exception ex)
{
throw new FormatException(Resources.Error_UnsupportedFormat, ex);
}
var info = new RepositoryInfo();
// If it has a repository, then try to get information from that
var repository = payload.Value<JObject>("repository");
if (repository != null)
{
if (request.UserAgent != null && request.UserAgent.StartsWith("Bitbucket", StringComparison.OrdinalIgnoreCase))
{
// bitbucket format
// { repository: { absolute_url: "/a/b", is_private: true }, canon_url: "https//..." }
string server = payload.Value<string>("canon_url"); // e.g. https://bitbucket.org
string path = repository.Value<string>("absolute_url"); // e.g. /davidebbo/testrepo/
// Combine them to get the full URL
info.RepositoryUrl = server + path;
info.IsPrivate = repository.Value<bool>("is_private");
info.Deployer = "Bitbucket";
// We don't get any refs from bitbucket, so write dummy string (we ignore it later anyway)
info.OldRef = "dummy";
// When there are no commits, set the new ref to an all-zero string to cause the logic in
// GitDeploymentRepository.GetReceiveInfo ignore the push
var commits = payload.Value<JArray>("commits");
info.NewRef = commits.Count == 0 ? "000" : "dummy";
}
else
{
// github format
// { repository: { url: "https//...", private: False }, ref: "", before: "", after: "" }
info.RepositoryUrl = repository.Value<string>("url");
info.IsPrivate = repository.Value<bool>("private");
// The format of ref is refs/something/something else
// For master it's normally refs/head/master
string @ref = payload.Value<string>("ref");
if (String.IsNullOrEmpty(@ref))
{
throw new FormatException(Resources.Error_UnsupportedFormat);
}
// Just get the last token
info.Branch = @ref.Split('/').Last();
info.Deployer = GetDeployer(request);
info.OldRef = payload.Value<string>("before");
info.NewRef = payload.Value<string>("after");
}
// private repo, use SSH
if (info.IsPrivate)
{
Uri uri = new Uri(info.RepositoryUrl);
if (uri.Scheme.StartsWith("http", StringComparison.OrdinalIgnoreCase))
{
info.Host = "git@" + uri.Host;
info.RepositoryUrl = info.Host + ":" + uri.AbsolutePath.TrimStart('/');
info.UseSSH = true;
}
}
}
else
{
// Look for the generic format
// { url: "", branch: "", deployer: "", oldRef: "", newRef: "" }
info.RepositoryUrl = payload.Value<string>("url");
info.Branch = payload.Value<string>("branch");
info.Deployer = payload.Value<string>("deployer");
info.OldRef = payload.Value<string>("oldRef");
info.NewRef = payload.Value<string>("newRef");
}
// If there's no specified branch assume master
if (String.IsNullOrEmpty(info.Branch))
{
// REVIEW: Is this correct
info.Branch = "master";
}
if (String.IsNullOrEmpty(info.RepositoryUrl))
{
throw new FormatException(Resources.Error_MissingRepositoryUrl);
}
return info;
}
public VsPackageManagerFactory(ISolutionManager solutionManager,
IPackageRepositoryFactory repositoryFactory,
IVsPackageSourceProvider packageSourceProvider,
IFileSystemProvider fileSystemProvider,
IRepositorySettings repositorySettings,
VsPackageInstallerEvents packageEvents,
IPackageRepository activePackageSourceRepository,
IVsFrameworkMultiTargeting frameworkMultiTargeting,
IMachineWideSettings machineWideSettings)
{
if (solutionManager == null)
{
throw new ArgumentNullException("solutionManager");
}
if (repositoryFactory == null)
{
throw new ArgumentNullException("repositoryFactory");
}
if (packageSourceProvider == null)
{
throw new ArgumentNullException("packageSourceProvider");
}
if (fileSystemProvider == null)
{
throw new ArgumentNullException("fileSystemProvider");
}
if (repositorySettings == null)
{
throw new ArgumentNullException("repositorySettings");
}
if (packageEvents == null)
{
throw new ArgumentNullException("packageEvents");
}
if (activePackageSourceRepository == null)
{
throw new ArgumentNullException("activePackageSourceRepository");
}
_fileSystemProvider = fileSystemProvider;
_repositorySettings = repositorySettings;
_solutionManager = solutionManager;
_repositoryFactory = repositoryFactory;
_packageSourceProvider = packageSourceProvider;
_packageEvents = packageEvents;
_activePackageSourceRepository = activePackageSourceRepository;
_frameworkMultiTargeting = frameworkMultiTargeting;
_machineWideSettings = machineWideSettings;
_solutionManager.SolutionClosing += (sender, e) =>
{
_repositoryInfo = null;
};
}
/// <summary>
/// Initializes a new instance of the <see cref="Github"/> class.
/// </summary>
/// <param name="repositoryInfo">The repository information.</param>
public Github(RepositoryInfo repositoryInfo)
{
_RepoInfo = repositoryInfo;
_LocalRepo = string.Format("Projects\\{0}", _RepoInfo.Name);
}
public static Store CreateStore(RepositoryInfo repositoryInfo) {
Store store = null;
if (repositoryInfo.typeName == RepositoryInfo.XmlStoreTypeName) {
store = new XmlStore(Path.GetDirectoryName(repositoryInfo.location), Path.GetExtension(repositoryInfo.location));
} else if (repositoryInfo.typeName == RepositoryInfo.SqlServerStoreTypeName) {
store = new SqlStore();
((SqlStore)store).DatabaseName = repositoryInfo.location;
((SqlStore)store).ServerName = repositoryInfo.computerName;
} else {
Debug.Fail(string.Format("Unsupported {0} value '{1}'", typeof(RepositoryInfo).Name, repositoryInfo));
}
return store;
}
private RepositoryInfo GetRepositoryInfo()
{
// Update the path if it needs updating
string path = _repositorySettings.RepositoryPath;
string configFolderPath = _repositorySettings.ConfigFolderPath;
if (_repositoryInfo == null ||
!_repositoryInfo.Path.Equals(path, StringComparison.OrdinalIgnoreCase) ||
!_repositoryInfo.ConfigFolderPath.Equals(configFolderPath, StringComparison.OrdinalIgnoreCase) ||
_solutionManager.IsSourceControlBound != _repositoryInfo.IsSourceControlBound)
{
IFileSystem fileSystem = _fileSystemProvider.GetFileSystem(path);
IFileSystem configSettingsFileSystem = GetConfigSettingsFileSystem(configFolderPath);
ISharedPackageRepository repository = new SharedPackageRepository(
new DefaultPackagePathResolver(fileSystem), fileSystem, configSettingsFileSystem);
_repositoryInfo = new RepositoryInfo(path, configFolderPath, fileSystem, repository);
}
return _repositoryInfo;
}
private bool RemoveFromRecentProjects(RepositoryInfo projectInfo) {
return recentProjects.Remove(projectInfo);
}
