/// <summary>
/// Compares changesets
/// </summary>
/// <param name="localPath"></param>
/// <param name="sourceChangesetId">Source changeset Id</param>
/// <param name="serverUrl">Server Uri</param>
/// <param name="srcPath">Source item path</param>
public static void CompareLocal(string localPath, string sourceChangesetId, string serverUri, string srcPath)
{
if (String.IsNullOrWhiteSpace(sourceChangesetId))
{
throw new ArgumentException("'sourceChangesetId' is null or empty.");
}
if (String.IsNullOrWhiteSpace(serverUri))
{
throw new TfsHistorySearchException("'serverUri' is null or empty.");
}
if (String.IsNullOrWhiteSpace(srcPath))
{
throw new TfsHistorySearchException("'srcPath' is null or empty.");
}
if (String.IsNullOrWhiteSpace(localPath))
{
throw new TfsHistorySearchException("'localPath' is null or empty.");
}
TfsTeamProjectCollection tc = new TfsTeamProjectCollection(new Uri(serverUri));
VersionControlServer vcs = tc.GetService(typeof(VersionControlServer)) as VersionControlServer;
//VersionSpec sourceVersion = VersionSpec.ParseSingleSpec(sourceChangesetId, vcs.TeamFoundationServer.AuthenticatedUserName);
VersionSpec sourceVersion = VersionSpec.ParseSingleSpec(sourceChangesetId, vcs.AuthorizedUser);
//VersionSpec targetVersion = VersionSpec.ParseSingleSpec(targetChangesetId, vcs.TeamFoundationServer.AuthenticatedUserName);
//Difference.DiffFiles(
Difference.VisualDiffItems(vcs, Difference.CreateTargetDiffItem(vcs, srcPath, sourceVersion, 0, sourceVersion), Difference.CreateTargetDiffItem(vcs, localPath, null, 0, null));
//Difference.VisualDiffFiles();
//Difference.VisualDiffItems(vcs,
// Difference.CreateTargetDiffItem(vcs, srcPath, sourceVersion, 0, sourceVersion),
// Difference.CreateTargetDiffItem(vcs, targetPath, targetVersion, 0, targetVersion));
}
public void GetUpdates()
{
var packages = new[] { new LucenePackage(path => null)
{
Id = "id1", Version = new StrictSemanticVersion("2.0")
} };
var constraint = new VersionSpec {
MinVersion = new SemanticVersion("1.0"), IsMinInclusive = false
};
repo.Setup(r => r.GetUpdates(
It.Is <IEnumerable <IPackage> >(p => p.Count() == 1),
false,
false,
It.Is <IEnumerable <FrameworkName> >(p => !p.Any()),
It.Is <IEnumerable <IVersionSpec> >(p => p.Single().ToString() == constraint.ToString())))
.Returns(packages);
var result = controller.GetUpdates("id1", "1.0", false, false, "", "");
repo.VerifyAll();
Assert.That(result, Is.InstanceOf <OkNegotiatedContentResult <IQueryable <ODataPackage> > >());
var queryable = ((OkNegotiatedContentResult <IQueryable <ODataPackage> >)result).Content;
Assert.That(queryable.Count(), Is.EqualTo(1));
Assert.That(queryable.First().Id, Is.EqualTo("id1"));
Assert.That(queryable.First().Version, Is.EqualTo("2.0"));
}
/// <summary>
/// Retrieves the latest changeset ID associated with a path
/// </summary>
/// <param name="localPath">A path on the local filesystem</param>
/// <param name="credentials">Credentials used to authenticate against the serer</param>
/// <returns></returns>
public int GetLatestChangesetId(string localPath, ICredentials credentials)
{
int latestChangesetId = 0;
string server;
Workstation workstation = new Workstation(versionControlClientAssembly);
WorkspaceInfo workspaceInfo = workstation.GetLocalWorkspaceInfo(localPath);
server = workspaceInfo.ServerUri.ToString();
VersionControlServer sourceControl = new VersionControlServer(clientAssembly, versionControlClientAssembly, server, credentials);
Workspace workspace = sourceControl.GetWorkspace(localPath);
WorkspaceVersionSpec workspaceVersionSpec = new WorkspaceVersionSpec(versionControlClientAssembly, workspace);
VersionSpec versionSpec = new VersionSpec(versionControlClientAssembly);
RecursionType recursionType = new RecursionType(versionControlClientAssembly);
IEnumerable history = sourceControl.QueryHistory(localPath, versionSpec.Latest, recursionType.Full, workspaceVersionSpec);
IEnumerator historyEnumerator = history.GetEnumerator();
Changeset latestChangeset = new Changeset(versionControlClientAssembly);
if (historyEnumerator.MoveNext())
{
latestChangeset = new Changeset(versionControlClientAssembly, historyEnumerator.Current);
}
if (latestChangeset.Instance != null)
{
latestChangesetId = latestChangeset.ChangesetId;
}
return(latestChangesetId);
}
public void HashCode()
{
var spec1 = new VersionSpec { MinVersion = new SemanticVersion("1.0"), MaxVersion = new SemanticVersion("2.0") };
var spec2 = new VersionSpec { MinVersion = new SemanticVersion("1.0"), MaxVersion = new SemanticVersion("2.0") };
Assert.Equal(spec1.GetHashCode(), spec2.GetHashCode());
}
public async Task <IFileSource> GetFileAsync(VersionSpec version)
{
BuildServices();
var container = Client.GetContainerReference(ContainerName);
await container.PrepContainer();
var path = BuildPath(version);
var blobs = await container.ListBlobsAsync();
if (MatchStrategy == null)
{
var blob = blobs
.OfType <CloudBlockBlob>()
.FirstOrDefault(
b => PatternMatcher.Match(b.Name, version)
);
if (blob == null)
{
throw new VersionNotFoundException($"No matches found from {blobs.Count} files using {PatternMatcher?.Name} matching!");
}
return(blob.ToSource(version));
}
var match = await MatchStrategy.MatchAsync(blobs, version);
return(match);
}
public void Equal_Not()
{
var spec1 = new VersionSpec { MinVersion = new SemanticVersion("1.0") };
var spec2 = new VersionSpec { MinVersion = new SemanticVersion("2.0") };
Assert.False(Equals(spec1, spec2));
}
public void Equal_Operator()
{
var spec1 = new VersionSpec();
var spec2 = new VersionSpec();
Assert.True(spec1 == spec2);
}
public SourceItem[] QueryItems(int revision, string path, Recursion recursion)
{
List <SourceItem> list = null;
persistentCache.UnitOfWork(delegate
{
string serverPath = GetServerPath(path);
if (serverPath == Constants.ServerRootPath && recursion == Recursion.None)
{
SourceItem[] items = sourceControlService.QueryItems(serverUrl, credentials, serverPath, RecursionType.None,
VersionSpec.FromChangeset(revision), DeletedState.NonDeleted,
ItemType.Any);
list = new List <SourceItem>(items);
return;
}
EnsureRevisionIsCached(revision, path);
string cacheKey = GetItemsListCacheKey(recursion, revision, serverPath);
list = persistentCache.GetList <SourceItem>(cacheKey);
list.Sort(delegate(SourceItem x, SourceItem y)
{
return(x.RemoteName.CompareTo(y.RemoteName));
});
});
return(list.ToArray());
}
public void ReadPackages_TwoPackagesInSourceRepositoryAndTwoNewerPackageVersionAvailableAndProjectHasConstraint_NewerPackageVersionThatMeetsConstraintIsDisplayed()
{
CreateViewModel();
var versionSpec = new VersionSpec();
versionSpec.MinVersion = new SemanticVersion("1.0");
versionSpec.IsMinInclusive = true;
versionSpec.MaxVersion = new SemanticVersion("2.0");
versionSpec.IsMaxInclusive = true;
var constraintProvider = new DefaultConstraintProvider();
constraintProvider.AddConstraint("Test", versionSpec);
solution.FakeProjectToReturnFromGetProject.ConstraintProvider = constraintProvider;
AddPackageToLocalRepository("Test", "1.0.0.0");
AddPackageToActiveRepository("Test", "1.0.0.0");
FakePackage expectedPackage = AddPackageToActiveRepository("Test", "2.0.0.0");
AddPackageToActiveRepository("Test", "3.0.0.0");
viewModel.ReadPackages();
CompleteReadPackagesTask();
var expectedPackages = new FakePackage[] {
expectedPackage
};
PackageCollectionAssert.AreEqual(expectedPackages, viewModel.PackageViewModels);
}
public void RenameUndeleteMergeTest()
{
int changesetId = AddBranch();
PendUndeleteRename(file);
SourceWorkspace.Merge(source.LocalPath, target.LocalPath,
VersionSpec.ParseSingleSpec(changesetId.ToString(), Environment.UserName),
VersionSpec.Latest, LockLevel.None, RecursionType.Full, MergeOptions.None);
CheckinMergeResolve(changesetId);
if (TestEnvironment.SourceTFSVersion == TFSVersionEnum.TFS2010)
{
Run();
// 1 extra merge item on source side is expected in dev10
VerifyHistory(1, 1);
//Changeset targetChangeset = diff.TargetChanges[0];
//Changeset sourceChangeset = diff.SourceChanges[0];
//diff.ChangesetDiff(ref targetChangeset, ref sourceChangeset);
//Assert.AreEqual(1, sourceChangeset.Changes.Length);
//Assert.AreEqual(ChangeType.Merge, sourceChangeset.Changes[0].ChangeType);
//Assert.AreEqual(0, targetChangeset.Changes.Length);
// verify content matches
Assert.IsTrue(VerifyContents());
}
else
{
RunAndValidate();
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
if (reader.TokenType == JsonToken.String)
{
return(serializer.Deserialize(reader, objectType));
}
JObject obj = JObject.Load(reader);
if (obj["Id"] != null)
{
var minVersion = obj["VersionSpec"]["MinVersion"].Value <string>();
var maxVersion = obj["VersionSpec"]["MaxVersion"].Value <string>();
var version = new VersionSpec()
{
IsMaxInclusive = obj["VersionSpec"]["IsMaxInclusive"].ToObject <bool>(),
MaxVersion = String.IsNullOrEmpty(maxVersion) ? null : new SemanticVersion(maxVersion),
IsMinInclusive = obj["VersionSpec"]["IsMinInclusive"].ToObject <bool>(),
MinVersion = String.IsNullOrEmpty(minVersion) ? null : new SemanticVersion(minVersion)
};
return(new PackageDependency(
obj["Id"].ToString(),
version,
obj["Include"].Value <string>(),
obj["Exclude"].Value <string>()));
}
return(serializer.Deserialize(reader, objectType));
}
public Task <IFileSource> GetFileAsync(VersionSpec version)
{
var message = "There is no storage backend currently configured! Use the settings file or environment variables to enable a remote backend.";
_logger.LogWarning(404, message);
throw new VersionNotFoundException(message);
}
public void Equal_Operator()
{
var spec1 = new VersionSpec();
var spec2 = new VersionSpec();
Assert.True(spec1 == spec2);
}
public void RenameEditUndeleteMergeTest()
{
int changesetId = AddBranch();
MergeDeletePendUndelete(m_file, changesetId);
SourceWorkspace.PendRename(m_file.ServerPath, m_file.NewServerPath);
SourceAdapter.EditFile(m_file.NewLocalPath);
SourceWorkspace.Merge(m_source.LocalPath, m_target.LocalPath,
VersionSpec.ParseSingleSpec(changesetId.ToString(), Environment.UserName),
VersionSpec.Latest, LockLevel.None, RecursionType.Full, MergeOptions.None);
resolveConflictAcceptThiers();
if (TestEnvironment.SourceEndPoint.IsTfsAdapter &&
TestEnvironment.SourceEndPoint.AdapterType >= AdapterType.TFS2010VC)
{
Run();
Assert.IsTrue(VerifyContents());
}
else
{
RunAndValidate();
}
}
public static string FindBranch(VersionControlServer tfs, string path, VersionSpec versionSpec = null)
{
if (versionSpec == null)
{
versionSpec = VersionSpec.Latest;
}
try {
while (!string.IsNullOrEmpty(path))
{
var item = tfs.GetItem(path, versionSpec, DeletedState.NonDeleted, GetItemsOptions.IncludeBranchInfo);
if (item == null)
{
return(null);
}
if (item.IsBranch)
{
return(path);
}
path = System.IO.Path.GetDirectoryName(path);
}
return(null);
}
catch (ItemNotMappedException) {
return(null);
}
}
public async Task <IFileSource> GetFileAsync(VersionSpec version)
{
if (Credentials == null)
{
_logger.LogCritical("Repo details not found! Please add GitHubStorage to your app configuration and restart the server.");
throw new UnauthorizedAccessException("Repository details not found in configuration!");
}
try
{
var releases = await Client.Repository.Release.GetAll(Credentials.Owner, Credentials.Repo);
if (MatchStrategy == null)
{
foreach (var release in releases)
{
var asset = release.Assets.FirstOrDefault(a => PatternMatcher.Match(a.Name, version));
if (asset != null)
{
var source = new GitHubFileSource(version, !release.Draft);
source.Build(asset);
return(source);
}
}
throw new VersionNotFoundException();
}
return(await MatchStrategy.MatchAsync(releases, version));
}
catch (RateLimitExceededException)
{
throw new VersionNotFoundException("GitHub API rate limit exceeded! Unable to fetch releases. Please add an API token to the `GitHubStorage/ApiToken` configuration key.");
}
}
public AzureHDInsightVersionSpec(VersionSpec versionSpec)
{
this.FriendlyName = versionSpec?.FriendlyName;
this.DisplayName = versionSpec?.DisplayName;
this.IsDefault = versionSpec?.IsDefault.ToString(); // ToDo: need to change IsDefault from string to bool, waiting for next major release
this.ComponentVersions = versionSpec?.ComponentVersions;
}
public void GetUpdatedPackages_OnePackageReferencedWithConstraintAndUpdatesAvailable_LatestVersionReturnedBasedOnConstraint()
{
AddPackageReference("Test", "1.0");
FakePackage package = AddPackageToSourceRepository("Test", "2.0");
FakePackage [] expectedPackages = new [] {
package
};
AddPackageToSourceRepository("Test", "3.0");
var versionSpec = new VersionSpec();
versionSpec.MinVersion = new SemanticVersion("1.0");
versionSpec.IsMinInclusive = true;
versionSpec.MaxVersion = new SemanticVersion("2.0");
versionSpec.IsMaxInclusive = true;
var constraintProvider = new DefaultConstraintProvider();
constraintProvider.AddConstraint("Test", versionSpec);
project.ConstraintProvider = constraintProvider;
var repository = new FakePackageRepository();
repository.FakePackages = sourceRepositoryPackages;
CreateUpdatedPackages(repository);
IEnumerable <IPackage> packages = updatedPackages.GetUpdatedPackages();
PackageCollectionAssert.AreEqual(expectedPackages, packages);
}
public void NotEqual_Operator()
{
var spec1 = new VersionSpec();
var spec2 = new VersionSpec { IsMaxInclusive = true };
Assert.True(spec1 != spec2);
}
public void RenameMergeTest()
{
MigrationItemStrings file1 = new MigrationItemStrings(source.Name + "file1.txt", source.Name + "renamed-file1.txt", TestEnvironment, true);
SourceAdapter.AddFile(file1.LocalPath);
MigrationItemStrings file2 = new MigrationItemStrings(source.Name + "file2.txt", source.Name + "renamed-file2.txt", TestEnvironment, true);
SourceAdapter.AddFile(file2.LocalPath);
int changesetId = AddBranch();
SourceAdapter.RenameItem(file.ServerPath, file.NewServerPath, AddComment);
SourceAdapter.RenameItem(file1.ServerPath, file1.NewServerPath, AddComment);
SourceAdapter.RenameItem(file2.ServerPath, file2.NewServerPath, AddComment);
SourceWorkspace.Merge(source.LocalPath, target.LocalPath,
VersionSpec.ParseSingleSpec(changesetId.ToString(), Environment.UserName),
VersionSpec.Latest, LockLevel.None, RecursionType.Full, MergeOptions.ForceMerge);
Conflict[] conflicts = SourceWorkspace.QueryConflicts(new string[] { "$/" }, true);
foreach (Conflict conflict in conflicts)
{
conflict.Resolution = Resolution.AcceptTheirs;
SourceWorkspace.ResolveConflict(conflict);
}
RunAndValidate();
}
public static List <ChangesetViewModel> GetChangesetHistory(ChangesetHistoryRequest request)
{
List <ChangesetViewModel> changesetList = new List <ChangesetViewModel>();
using (TfsTeamProjectCollection tpc = new TfsTeamProjectCollection(new Uri(request.TFSUrl)))
{
tpc.EnsureAuthenticated();
VersionControlServer vcs = tpc.GetService <VersionControlServer>();
VersionSpec fromDateVersion = null;
VersionSpec toDateVersion = null;
if (request.FromDate != DateTime.MinValue || request.ToDate != DateTime.MinValue)
{
fromDateVersion = new DateVersionSpec(request.FromDate.AddDays(-1));
toDateVersion = new DateVersionSpec(request.ToDate);
}
IEnumerable changesets = vcs.QueryHistory(request.ReleaseBranchUrl, VersionSpec.Latest,
0, RecursionType.Full, null, fromDateVersion, toDateVersion, int.MaxValue, true, true);
var ignoreUsers = request.IgnoreFromUsers;
foreach (Changeset changeset in changesets)
{
if (!ignoreUsers.Any(n => changeset.Owner.ToLower().Contains(n) || changeset.OwnerDisplayName.ToLower().Contains(n)))
{
changesetList.Add(new ChangesetViewModel()
{
ChangesetId = changeset.ChangesetId, Owner = changeset.OwnerDisplayName ?? changeset.Owner, Comment = changeset.Comment, CheckInDateTime = changeset.CreationDate
});
}
}
}
return(changesetList);
}
public void Equal_VersionsSpecified()
{
var spec1 = new VersionSpec { MinVersion = new SemanticVersion("1.0"), MaxVersion = new SemanticVersion("2.0") };
var spec2 = new VersionSpec { MinVersion = new SemanticVersion("1.0"), MaxVersion = new SemanticVersion("2.0") };
Assert.True(Equals(spec1, spec2));
}
private void BtnGetInformation_Click(object sender, EventArgs e)
{
TfsTeamProjectCollection ProjectCollection = new TfsTeamProjectCollection(new Uri("http://example.com:8080/tfs/ProjectCollection"));
ProjectCollection.Connect(ConnectOptions.None);
var vcs = ProjectCollection.GetService <VersionControlServer>();
VersionSpec versionFrom = VersionSpec.ParseSingleSpec("C529", null);
VersionSpec versionTo = VersionSpec.Latest;
string serverPath = @"$/";
List <Changeset> Changesets = vcs.QueryHistory(serverPath,
VersionSpec.Latest,
0,
RecursionType.Full,
null,
versionFrom,
versionTo,
Int32.MaxValue,
true,
false
).Cast <Changeset>().ToList <Changeset>();
BaseChangesets = Changesets;
if (BaseChangesets != null)
{
GrpDateFilter.Enabled = true;
}
}
public AzureHDInsightVersionSpec(VersionSpec versionSpec)
{
this.FriendlyName = versionSpec?.FriendlyName;
this.DisplayName = versionSpec?.DisplayName;
this.IsDefault = versionSpec?.IsDefault;
this.ComponentVersions = versionSpec?.ComponentVersions;
}
public void Equal_Default()
{
var spec1 = new VersionSpec();
var spec2 = new VersionSpec();
Assert.True(Equals(spec1, spec2));
}
private void FixUpVersionSpec(ref VersionSpec spec)
{
if (spec is LabelVersionSpec)
{
spec = this.ConvertToChangesetSpec((LabelVersionSpec)spec);
}
}
private void FetchChangesets(VersionControlServer server, string path, VersionSpec version)
{
var changesets = server.QueryHistory(path, version, 0, RecursionType.None, null, null, version, int.MaxValue, true, false, true, false);
foreach (Changeset changeset in changesets)
{
if (changeset.Changes.Length != 1)
{
throw new InvalidOperationException("Expected exactly 1 change, but got " + changeset.Changes.Length + " for ChangesetId " + changeset.ChangesetId);
}
this.changesets.Add(changeset);
filenames.Add(null);
manualResetEvents.Add(null);
var change = changeset.Changes[0];
if (change.ChangeType.HasFlag(ChangeType.Branch))
{
var branchHistoryTree = server.GetBranchHistory(new[] { new ItemSpec(change.Item.ServerItem, RecursionType.None) }, new ChangesetVersionSpec(changeset.ChangesetId));
if (branchHistoryTree == null || branchHistoryTree.Length == 0 || branchHistoryTree[0].Length == 0)
{
continue;
}
var item = branchHistoryTree[0][0].GetRequestedItem().Relative.BranchFromItem;
if (item != null)
{
FetchChangesets(server, item.ServerItem, new ChangesetVersionSpec(item.ChangesetId));
}
}
}
}
public void Equal_Default()
{
var spec1 = new VersionSpec();
var spec2 = new VersionSpec();
Assert.True(Equals(spec1, spec2));
}
private VersionSpec GetToVersion()
{
VersionSpec Spec = this.ToVersionSpec.GetVersionSpec();
this.FixUpVersionSpec(ref Spec);
return(Spec);
}
public void MergeMovesTest()
{
MigrationItemStrings branch = new MigrationItemStrings("source/", "target/", TestEnvironment, true);
MigrationItemStrings file = new MigrationItemStrings("source/file.txt", "source/sub/file.txt", TestEnvironment, true);
MigrationItemStrings file2 = new MigrationItemStrings("source/file2.txt", "source/sub/file2.txt", TestEnvironment, true);
SourceAdapter.AddFile(file.LocalPath);
SourceAdapter.AddFile(file2.LocalPath);
int branchChangeset = SourceAdapter.BranchItem(branch.ServerPath, branch.NewServerPath);
SourceAdapter.EditFile(file.LocalPath);
SourceAdapter.EditFile(file.LocalPath);
SourceAdapter.EditFile(m_extraFile.LocalPath);
SourceAdapter.RenameItem(file.ServerPath, file.NewServerPath);
SourceAdapter.RenameItem(file2.ServerPath, file2.NewServerPath);
SourceWorkspace.Merge(branch.ServerPath, branch.NewServerPath,
VersionSpec.ParseSingleSpec(branchChangeset.ToString(),
Environment.UserName), VersionSpec.Latest, LockLevel.None, RecursionType.Full, MergeOptions.None);
ResolveConflicts(Resolution.AcceptTheirs);
SourceWorkspace.CheckIn(SourceWorkspace.GetPendingChanges(), MergeComment);
RunAndValidate();
}
public override void Execute()
{
var package = Package;
var packageRepositories = _moduleCatalog.GetAllPackageRepositories(true).ToList();
var versionSpec = new VersionSpec
{
IsMinInclusive = true,
MinVersion = package.Version,
IsMaxInclusive = true,
MaxVersion = package.Version
};
var packagesToDownload = ResolveDependencies(package.Id, versionSpec, packageRepositories);
foreach (var packageToDownload in packagesToDownload)
{
Log.Debug("Installing package '{0}' from source '{1}'", packageToDownload.Package.Id, packageToDownload.PackageRepository.Source);
var packageManager = new PackageManager(packageToDownload.PackageRepository, OutputDirectory);
lock (_syncObj)
{
packageManager.InstallPackage(packageToDownload.Package, IgnoreDependencies, AllowPrereleaseVersions);
}
}
}
/// <summary>
/// Compares changesets
/// </summary>
/// <param name="sourceChangesetId">Source changeset Id</param>
/// <param name="targetChangesetId">Target changeset Id</param>
/// <param name="serverUrl">Server Uri</param>
/// <param name="srcPath">Source item path</param>
/// <param name="targetPath">Target item path</param>
public static void Compare(string sourceChangesetId, string targetChangesetId, string serverUri, string srcPath, string targetPath)
{
if (String.IsNullOrWhiteSpace(sourceChangesetId))
{
throw new ArgumentException("'sourceChangesetId' is null or empty.");
}
if (String.IsNullOrWhiteSpace(targetChangesetId))
{
throw new ArgumentException("'targetChangesetId' is null or empty.");
}
if (String.IsNullOrWhiteSpace(serverUri))
{
throw new ArgumentException("'serverUri' is null or empty.");
}
if (String.IsNullOrWhiteSpace(srcPath))
{
throw new ArgumentException("'srcPath' is null or empty.");
}
if (String.IsNullOrWhiteSpace(targetPath))
{
throw new ArgumentException("'targetPath' is null or empty.");
}
TfsTeamProjectCollection tc = new TfsTeamProjectCollection(new Uri(serverUri));
VersionControlServer vcs = tc.GetService(typeof(VersionControlServer)) as VersionControlServer;
VersionSpec sourceVersion = VersionSpec.ParseSingleSpec(sourceChangesetId, vcs.AuthorizedUser);
VersionSpec targetVersion = VersionSpec.ParseSingleSpec(targetChangesetId, vcs.AuthorizedUser);
Difference.VisualDiffItems(vcs,
Difference.CreateTargetDiffItem(vcs, srcPath, sourceVersion, 0, sourceVersion),
Difference.CreateTargetDiffItem(vcs, targetPath, targetVersion, 0, targetVersion));
}
public override void Run()
{
RecursionType rtype = OptionRecursive ? RecursionType.Full : RecursionType.None;
VersionSpec version = VersionFromString(OptionVersion);
List <ItemSpec> itemSpecs = new List <ItemSpec>();
foreach (string item in Arguments)
{
string fpath = (VersionControlPath.IsServerItem(item))? item : Path.GetFullPath(item);
itemSpecs.Add(new ItemSpec(fpath, rtype));
}
BranchHistoryTreeItem[][] treeItemsArray = VersionControlServer.GetBranchHistory(itemSpecs.ToArray(), version);
foreach (BranchHistoryTreeItem[] treeItems in treeItemsArray)
{
//Console.WriteLine("New TreeItem");
foreach (BranchHistoryTreeItem treeItem in treeItems)
{
//Console.WriteLine("Relative: " + treeItem.Relative);
//Console.WriteLine(treeItem.Relative.ServerItem);
foreach (Object obj in treeItem.Children)
{
BranchRelative branch = obj as BranchRelative;
Item fromItem = branch.BranchFromItem;
Console.WriteLine(fromItem.ServerItem);
Item toItem = branch.BranchToItem;
Console.Write(">> \t" + toItem.ServerItem);
Console.WriteLine("\tBranched from version " + fromItem.ChangesetId + " <<");
}
}
}
}
public GetStatus UpdatePathFromServer(string[] paths)
{
// process command options
RecursionType folderRecursion = OptionRecursive ? RecursionType.Full : RecursionType.OneLevel;
bool getSetting = Settings.Current.GetAsBool("Get.Recursive");
if (getSetting)
{
folderRecursion = RecursionType.Full;
}
VersionSpec version = VersionFromString(OptionVersion);
List <GetRequest> requests = new List <GetRequest>();
foreach (string path in paths)
{
RecursionType recursion = RecursionType.None;
if (Directory.Exists(path))
{
recursion = folderRecursion;
}
if (path[0] != '$')
{
requests.Add(new GetRequest(Path.GetFullPath(path), recursion, version));
}
else
{
requests.Add(new GetRequest(path, recursion, version));
}
}
return(workspace.Get(requests.ToArray(), GetOptionFlags()));
}
public async Task <IFileSource> GetFileAsync(VersionSpec version)
{
var blobs = new List <S3Object>();
using (var client = BuildClient())
{
ListObjectsV2Request request = new ListObjectsV2Request
{
BucketName = BucketName,
MaxKeys = 10
};
ListObjectsV2Response response;
do
{
response = await client.ListObjectsV2Async(request);
blobs.AddRange(response.S3Objects);
request.ContinuationToken = response.NextContinuationToken;
} while (response.IsTruncated == true);
}
if (MatchStrategy == null)
{
var blob = blobs.FirstOrDefault(
o => PatternMatcher.Match(o.Key, version)
);
if (blob == null)
{
throw new VersionNotFoundException();
}
return(ToSource(version, blob));
}
var match = await MatchStrategy.MatchAsync(blobs, version);
return(match);
}
public async Task <IFileSource> GetFileAsync(VersionSpec version)
{
var pattern = BuildPattern(version);
//TODO: refactor this to use strategies and matchers
var files = await Search(pattern);
if (!files.Any())
{
throw new VersionNotFoundException();
}
var firstMatch = files.First();
using (var client = BuildClient())
{
var req = new GetPreSignedUrlRequest
{
BucketName = BucketName,
Key = firstMatch.Key,
Expires = DateTime.Now.AddMinutes(15)
};
var url = client.GetPreSignedURL(req);
return(new S3FileSource(new Uri(url))
{
Metadata = new FileMetadata(firstMatch.Size, firstMatch.Key.Split('/', '\\', ':').Last()),
Version = version
});
}
}
public ChangeRequest(string path, RequestType requestType, ItemType itemType,
RecursionType recursion, LockLevel lockLevel, VersionSpec version)
{
this.Item = new ItemSpec(path, recursion);
this.RequestType = requestType;
this.ItemType = itemType;
this.LockLevel = lockLevel;
this.VersionSpec = version;
}
public void ToStringMinVersionExclusive()
{
// Arrange
var spec = new VersionSpec {
IsMinInclusive = false,
MinVersion = new Version("1.0"),
};
// Act
string value = spec.ToString();
// Assert
Assert.AreEqual("(1.0, )", value);
}
public void ToStringMaxVersionInclusive()
{
// Arrange
var spec = new VersionSpec {
IsMaxInclusive = true,
MaxVersion = new Version("1.0"),
};
// Act
string value = spec.ToString();
// Assert
Assert.AreEqual("(, 1.0]", value);
}
public void ToStringMinVersionInclusive()
{
// Arrange
var spec = new VersionSpec
{
IsMinInclusive = true,
MinVersion = new SemanticVersion("1.0"),
};
// Act
string value = spec.ToString();
// Assert
Assert.Equal("1.0", value);
}
public void ToStringMaxVersionExclusive()
{
// Arrange
var spec = new VersionSpec
{
IsMaxInclusive = false,
MaxVersion = new SemanticVersion("1.0"),
};
// Act
string value = spec.ToString();
// Assert
Assert.Equal("(, 1.0)", value);
}
private static IVersionSpec CreateVersionSpec(
string minVersion = null,
string maxVersion = null,
bool isMinInclusive = true,
bool isMaxInclusive = false)
{
var versionSpec = new VersionSpec();
versionSpec.IsMaxInclusive = isMaxInclusive;
versionSpec.IsMinInclusive = isMinInclusive;
if (!string.IsNullOrWhiteSpace(maxVersion))
{
versionSpec.MaxVersion = new SemanticVersion(maxVersion);
}
if (!string.IsNullOrWhiteSpace(minVersion))
{
versionSpec.MinVersion = new SemanticVersion(minVersion);
}
return versionSpec;
}
public IEnumerable<PackageDependency> GetPackageDependenciesFromPackagesConfig(XDocument packagesConfigXml)
{
List<PackageDependency> packageDependencies = new List<PackageDependency>();
if (packagesConfigXml.Root != null)
{
foreach (XElement packageElement in packagesConfigXml.Root.Elements("package"))
{
XAttribute idAttribute = packageElement.Attribute("id");
XAttribute versionAttribute = packageElement.Attribute("version");
if (idAttribute != null && versionAttribute != null)
{
string id = idAttribute.Value;
IVersionSpec versionSpec = new VersionSpec(new SemanticVersion(versionAttribute.Value));
PackageDependency packageInfo = new PackageDependency(id, versionSpec);
packageDependencies.Add(packageInfo);
}
}
}
return packageDependencies;
}
public void GetUpdates()
{
var packages = new[] {new LucenePackage(path => null) {Id = "id1", Version = new StrictSemanticVersion("2.0")}};
var constraint = new VersionSpec {MinVersion = new SemanticVersion("1.0"), IsMinInclusive = false};
repo.Setup(r => r.GetUpdates(
It.Is<IEnumerable<IPackage>>(p => p.Count() == 1),
false,
false,
It.Is<IEnumerable<FrameworkName>>(p => !p.Any()),
It.Is<IEnumerable<IVersionSpec>>(p => p.Single().ToString() == constraint.ToString())))
.Returns(packages);
var result = service.GetUpdates("id1", "1.0", false, false, "", "");
repo.VerifyAll();
Assert.That(result.Count(), Is.EqualTo(1));
Assert.That(result.First().Id, Is.EqualTo("id1"));
Assert.That(result.First().Version, Is.EqualTo("2.0"));
}
public void GetUpdates()
{
var packages = new[] {new LucenePackage(path => null) {Id = "id1", Version = new StrictSemanticVersion("2.0")}};
var constraint = new VersionSpec {MinVersion = new SemanticVersion("1.0"), IsMinInclusive = false};
repo.Setup(r => r.GetUpdates(
It.Is<IEnumerable<IPackage>>(p => p.Count() == 1),
false,
false,
It.Is<IEnumerable<FrameworkName>>(p => !p.Any()),
It.Is<IEnumerable<IVersionSpec>>(p => p.Single().ToString() == constraint.ToString())))
.Returns(packages);
var result = controller.GetUpdates("id1", "1.0", false, false, "", "");
repo.VerifyAll();
Assert.That(result, Is.InstanceOf<OkNegotiatedContentResult<IQueryable<ODataPackage>>>());
var queryable = ((OkNegotiatedContentResult<IQueryable<ODataPackage>>) result).Content;
Assert.That(queryable.Count(), Is.EqualTo(1));
Assert.That(queryable.First().Id, Is.EqualTo("id1"));
Assert.That(queryable.First().Version, Is.EqualTo("2.0"));
}
/// <summary>
/// Returns the largest version spec we can think of to start narrowing down from.
/// </summary>
/// <returns></returns>
private static VersionSpec ReturnLargestVersionSpec()
{
VersionSpec smallest = new VersionSpec()
{
MinVersion = SemanticVersion.Parse("0.0.0.0"),
MaxVersion = SemanticVersion.Parse("999.999.999.999"),
IsMinInclusive = true,
IsMaxInclusive = true
};
return smallest;
}
public void ParseVersionParsesTokensVersionsCorrectly(string versionString, VersionSpec versionSpec)
{
// Act
var actual = VersionUtility.ParseVersionSpec(versionString);
// Assert
Assert.Equal(versionSpec.IsMinInclusive, actual.IsMinInclusive);
Assert.Equal(versionSpec.IsMaxInclusive, actual.IsMaxInclusive);
Assert.Equal(versionSpec.MinVersion, actual.MinVersion);
Assert.Equal(versionSpec.MaxVersion, actual.MaxVersion);
}
/// <summary>
/// Resolves the installable version.
/// </summary>
/// <param name="remoteRepository"> </param>
/// <param name="packageReference"> </param>
/// <returns></returns>
public IPackage ResolveLatestInstallablePackage(IPackageRepository remoteRepository, PackageReference packageReference)
{
IPackage package = null;
if (Latest)
{
//We can only work on an AggregateRepository, just return null if we dont get one.
var aggregateRepository = remoteRepository as AggregateRepository;
if (aggregateRepository == null) return null;
var versionSpecComparer = new VersionSpecEqualityComparer(packageReference.VersionConstraint);
var defaultVersionSpec = new VersionSpec();
if (versionSpecComparer.Equals(defaultVersionSpec))
{
//First, check to see if we have already checked for this ID, and if so, return the right version
if (_cache.TryCacheHitByIsLatest(packageReference.Id, out package)) return package;
//TODO need to check where we need to get the bools for this call....assuming a bit much here.
Console.Log(MessageLevel.Info, "Checking for latest package: {0}", packageReference.Id);
try
{
IPackage p = aggregateRepository.FindLatestPackage(packageReference.Id);
if (p != null)
{
Console.Log(MessageLevel.Info, "Using latest version : {0} {1}", p.Id, p.ToString());
//Only add if there is no constraint....
_cache.AddCacheEntryByIsLatest(p);
package = p;
}
else
{
Console.Log(MessageLevel.Info,
"Latest version requested, however {0} cannot be found on feed.",
packageReference.Id);
return null;
}
}
catch (NullReferenceException)
{
Console.Log(MessageLevel.Error,
"One of the feeds threw an error, a package called {0} could not be found.",
packageReference.Id);
return null;
}
}
else
{
Console.Log(MessageLevel.Info, "Checking for latest package: {0} using constraint {1}",
packageReference.Id, packageReference.VersionConstraint);
if (_cache.TryCacheHitByVersionConstraint(packageReference, out package)) return package;
try
{
IPackage p = aggregateRepository.FindLatestPackage(packageReference.Id,
packageReference.VersionConstraint);
if (p != null)
{
package = p;
_cache.AddCacheEntryByConstraint(package, packageReference.VersionConstraint);
Console.Log(MessageLevel.Info, "Using constrained version : {0} {1}, constrained by {2}",
packageReference.Id, p.Version.ToString(), packageReference.VersionConstraint);
}
else
{
Console.Log(MessageLevel.Error,
"Latest version requested, however {0} cannot be satisfied on feed using constraint {1}.",
packageReference.Id, packageReference.VersionConstraint);
return null;
}
}
catch (NullReferenceException)
{
Console.Log(MessageLevel.Error,
"One of the feeds threw an error, a package called {0} could not be found.",
packageReference.Id);
return null;
}
}
}
return package;
}
public List<Changeset> QueryHistory(ItemSpec item, VersionSpec versionItem,
VersionSpec versionFrom, VersionSpec versionTo, int maxCount = short.MaxValue)
{
var invoker = new SoapInvoker(this);
var msg = invoker.CreateEnvelope("QueryHistory");
msg.Add(item.ToXml(MessageNs + "itemSpec"));
msg.Add(versionItem.ToXml(MessageNs + "versionItem"));
if (versionFrom != null)
msg.Add(versionFrom.ToXml(MessageNs + "versionFrom"));
if (versionTo != null)
msg.Add(versionTo.ToXml(MessageNs + "versionTo"));
msg.Add(new XElement(MessageNs + "maxCount", maxCount));
msg.Add(new XElement(MessageNs + "includeFiles", false));
msg.Add(new XElement(MessageNs + "generateDownloadUrls", false));
msg.Add(new XElement(MessageNs + "slotMode", false));
msg.Add(new XElement(MessageNs + "sortAscending", false));
var result = invoker.InvokeResult();
return result.Elements(MessageNs + "Changeset").Select(Changeset.FromXml).ToList();
}
public List<Item> QueryItems(Workspace workspace, ItemSpec itemSpec, VersionSpec versionSpec,
DeletedState deletedState, ItemType itemType,
bool includeDownloadInfo)
{
if (workspace == null)
return QueryItems(itemSpec, versionSpec, deletedState, itemType, includeDownloadInfo);
return QueryItems(workspace.Name, workspace.OwnerName, new [] { itemSpec }, versionSpec, deletedState, itemType, includeDownloadInfo);
}
public List<Item> QueryItems(ItemSpec itemSpec, VersionSpec versionSpec,
DeletedState deletedState, ItemType itemType,
bool includeDownloadInfo)
{
return QueryItems(string.Empty, string.Empty, new [] { itemSpec }, versionSpec, deletedState, itemType, includeDownloadInfo);
}
public void ValidateDependenciesDoesNotThrowIfDependencyForAPrereleaseVersionIsPrerelease(VersionSpec versionSpec)
{
// Arrange
var dependencies = new[] {
new PackageDependency("A", versionSpec),
new PackageDependency("B", new VersionSpec()),
};
var packageVersion = new SemanticVersion("1.0.0-beta");
var dependencySets = new PackageDependencySet[] {
new PackageDependencySet(null, dependencies)
};
// Act
PackageBuilder.ValidateDependencySets(packageVersion, dependencySets);
// Assert
// If we've got this far, no exceptions were thrown.
Assert.True(true);
}
public void ValidateDependenciesThrowsIfAnyDependencyForAStableReleaseIsPrerelease(VersionSpec versionSpec)
{
// Arrange
var badDependency = new PackageDependency("A", versionSpec);
var dependencies = new[] {
badDependency,
new PackageDependency("B", new VersionSpec()),
};
var packageVersion = new SemanticVersion("1.0.0");
var dependencySets = new PackageDependencySet[] {
new PackageDependencySet(null, dependencies)
};
// Act and Assert
ExceptionAssert.Throws<InvalidDataException>(() => PackageBuilder.ValidateDependencySets(packageVersion, dependencySets),
String.Format(CultureInfo.InvariantCulture,
"A stable release of a package should not have on a prerelease dependency. Either modify the version spec of dependency \"{0}\" or update the version field.",
badDependency));
}
public DiffItemVersionedFile(Item item, VersionSpec versionSpec)
{
this.item = item;
this.versionSpec = versionSpec;
this.label = item.ServerItem;
}
/// <summary>
/// Retrieves the latest changeset ID associated with a path
/// </summary>
/// <param name="localPath">A path on the local filesystem</param>
/// <param name="credentials">Credentials used to authenticate against the serer</param>
/// <returns></returns>
public int GetLatestChangesetId(string localPath, ICredentials credentials)
{
int latestChangesetId = 0;
string server;
Workstation workstation = new Workstation(versionControlClientAssembly);
WorkspaceInfo workspaceInfo = workstation.GetLocalWorkspaceInfo(localPath);
server = workspaceInfo.ServerUri.ToString();
VersionControlServer sourceControl = new VersionControlServer(clientAssembly, versionControlClientAssembly, server, credentials);
Workspace workspace = sourceControl.GetWorkspace(localPath);
WorkspaceVersionSpec workspaceVersionSpec = new WorkspaceVersionSpec(versionControlClientAssembly, workspace);
VersionSpec versionSpec = new VersionSpec(versionControlClientAssembly);
RecursionType recursionType = new RecursionType(versionControlClientAssembly);
IEnumerable history = sourceControl.QueryHistory(localPath, versionSpec.Latest, recursionType.Full, workspaceVersionSpec);
IEnumerator historyEnumerator = history.GetEnumerator();
Changeset latestChangeset = new Changeset(versionControlClientAssembly);
if (historyEnumerator.MoveNext())
{
latestChangeset = new Changeset(versionControlClientAssembly, historyEnumerator.Current);
}
if (latestChangeset.Instance != null)
{
latestChangesetId = latestChangeset.ChangesetId;
}
return latestChangesetId;
}
internal static PackageDependency CreateExact(string id, string version)
{
var versionSpec = new VersionSpec(new SemanticVersion(version));
return new PackageDependency(id, versionSpec);
}
internal GetRequest(VersionSpec versionSpec)
{
this.VersionSpec = versionSpec;
}
public void ToStringMinVersionInclusiveMaxExclusive()
{
// Arrange
var spec = new VersionSpec {
IsMaxInclusive = false,
IsMinInclusive = true,
MaxVersion = new Version("4.0"),
MinVersion = new Version("1.0"),
};
// Act
string value = spec.ToString();
// Assert
Assert.AreEqual("[1.0, 4.0)", value);
}
public GetRequest(ItemSpec itemSpec, VersionSpec versionSpec)
{
this.ItemSpec = itemSpec;
this.VersionSpec = versionSpec;
}
// <QueryItems xmlns="http://schemas.microsoft.com/TeamFoundation/2005/06/VersionControl/ClientServices/03">
// <workspaceName>string</workspaceName>
// <workspaceOwner>string</workspaceOwner>
// <items>
// <ItemSpec item="string" recurse="None or OneLevel or Full" did="int" />
// <ItemSpec item="string" recurse="None or OneLevel or Full" did="int" />
// </items>
// <version />
// <deletedState>NonDeleted or Deleted or Any</deletedState>
// <itemType>Any or Folder or File</itemType>
// <generateDownloadUrls>boolean</generateDownloadUrls>
// <options>int</options>
// </QueryItems>
public List<Item> QueryItems(string workspaceName, string workspaceOwner, ItemSpec[] itemSpecs, VersionSpec versionSpec,
DeletedState deletedState, ItemType itemType,
bool includeDownloadInfo)
{
var invoker = new SoapInvoker(this);
var msg = invoker.CreateEnvelope("QueryItems");
if (!string.IsNullOrEmpty(workspaceName))
msg.Add(new XElement(MessageNs + "workspaceName", workspaceName));
if (!string.IsNullOrEmpty(workspaceOwner))
msg.Add(new XElement(MessageNs + "workspaceOwner", workspaceOwner));
msg.Add(new XElement(MessageNs + "items", itemSpecs.Select(itemSpec => itemSpec.ToXml(MessageNs + "ItemSpec"))));
msg.Add(versionSpec.ToXml(MessageNs + "version"));
msg.Add(new XElement(MessageNs + "deletedState", deletedState));
msg.Add(new XElement(MessageNs + "itemType", itemType));
msg.Add(new XElement(MessageNs + "generateDownloadUrls", includeDownloadInfo.ToLowString()));
var result = invoker.InvokeResult();
return result.Descendants(MessageNs + "Item").Select(Item.FromXml).ToList();
}
