public Workspace CreateWorkSpace(VersionControlServer vcs, string wsName)
{
try
{
if (vcs.DeleteWorkspace(wsName, vcs.AuthorizedUser))
{
$"Successfully deleted workspace {wsName}".Info();
}
}
catch (Exception e)
{
$"createWorkspace: {e.Message}".Error();
}
try
{
var options = new CreateWorkspaceParameters(wsName)
{
WorkspaceOptions = WorkspaceOptions.None,
OwnerName = vcs.AuthorizedUser,
Location = WorkspaceLocation.Server
};
var workSpace = vcs.CreateWorkspace(options);
$"Workspace created: {workSpace.Name}".Trace();
return(workSpace);
}
catch (Exception e)
{
$"createWorkspace: {e.Message}".Error();
throw;
}
}
public static Workspace CreateWorkspace(VersionControlServer versionControlServer, string name, string owner, string comment)
{
CreateWorkspaceParameters createWorkspaceParameters = new CreateWorkspaceParameters(name);
createWorkspaceParameters.Location = WorkspaceLocation.Server;
createWorkspaceParameters.OwnerName = owner;
createWorkspaceParameters.Comment = comment;
return(versionControlServer.CreateWorkspace(createWorkspaceParameters));
}
internal static Workspace WorkspaceCreate(VersionControlServer vcs, string tfsProject, string workspaceName, string localWorkspaceFolder)
{
var workspaceParams = new CreateWorkspaceParameters(workspaceName)
{
Computer = Environment.MachineName,
Folders = new[]
{
new WorkingFolder(string.Format(@"$/{0}", tfsProject), localWorkspaceFolder)
},
Location = Microsoft.TeamFoundation.VersionControl.Common.WorkspaceLocation.Local,
OwnerDisplayName = Environment.UserName
};
return(vcs.CreateWorkspace(workspaceParams));
}
private void DoFullGet()
{
try
{
#if DEBUG
Thread.Sleep(5000);
#endif
Configuration = new Config();
Configuration.Init();
var cts = new CancellationTokenSource();
$"Get info for all TPCs and all projects".Info();
var sw = new Stopwatch();
sw.Start();
var lpc = GetTeamProjectCollections().AsParallel();
Func <TfsTeamProjectCollection, string> workspaceName = projColl =>
{
var str = $"{Guid.NewGuid()}_{projColl.GetProjectCollectionName()}";
$"workspaceName: {str}".Trace();
return(str);
};
Func <VersionControlServer, string, Workspace> createWorkSpace = (vcs,
wsName) =>
{
try
{
if (vcs.DeleteWorkspace(wsName, vcs.AuthorizedUser))
{
// TODO log
}
}
catch (Exception e)
{
$"createWorkspace: {e.Message}".Error();
}
try
{
var options = new CreateWorkspaceParameters(wsName)
{
WorkspaceOptions = WorkspaceOptions.None,
OwnerName = vcs.AuthorizedUser,
Location = WorkspaceLocation.Server
};
var workSpace = vcs.CreateWorkspace(options);
$"Workspace created: {workSpace.Name}".Trace();
return(workSpace);
}
catch (Exception e)
{
$"createWorkspace: {e.Message}".Error();
throw;
}
};
Action <TfsTeamProjectCollection> dropWorkspaces = collection =>
{
try
{
var vcs = collection.GetService <VersionControlServer>();
var wss = vcs.QueryWorkspaces(null, vcs.AuthorizedUser, Environment.MachineName);
foreach (var workspace in wss)
{
if (!workspace.Delete())
{
$"Failed to delete {workspace.Name}".Error();
}
else
{
$"Deleted {workspace.Name}".Info();
}
}
}
catch (Exception e)
{
e.Error();
throw;
}
};
Action <TfsTeamProjectCollection> dropMappings = (collection) =>
{
try
{
var vcs = collection.GetService <VersionControlServer>();
var wss = vcs.QueryWorkspaces(null, vcs.AuthorizedUser, null);
var localPath = collection.GetProjectCollectionLocalPath(Globals.TfsRoot);
var withPath = wss.Select(workspace => Tuple.Create(workspace, workspace.TryGetWorkingFolderForServerItem(collection.Uri.AbsoluteUri)));
foreach (var tuple in withPath)
{
if (tuple.Item1 != null && tuple.Item2 != null)
{
$"Dropping {tuple.Item2.LocalItem} for workspace {tuple.Item1.Name}".Info();
tuple.Item1.DeleteMapping(tuple.Item2);
}
}
}
catch (Exception e)
{
e.Error();
}
};
Func <Workspace, TfsTeamProjectCollection, Workspace> mapWorkspace = (ws,
pc) =>
{
try
{
var serverPath = "$/";
var localPath = pc.GetProjectCollectionLocalPath(Globals.TfsRoot);
$"mapWorkspace: {nameof(serverPath)} = {serverPath}".Trace();
$"mapWorkspace: {nameof(localPath)} = {localPath}".Trace();
var vcs = pc.GetService <VersionControlServer>();
var lws = Workstation.Current.RemoveCachedWorkspaceInfo(vcs);
var wss = vcs.QueryWorkspaces(null, vcs.AuthorizedUser, null);
foreach (var workspace in wss)
{
$"Checking workspace {workspace.Name} for mapping of local path {localPath}".Info();
if (workspace.IsLocalPathMapped(localPath))
{
var wf = workspace.TryGetWorkingFolderForLocalItem(localPath);
workspace.DeleteMapping(wf);
$"Deleted {localPath} mapping from workspace {workspace.Name}".Info();
}
}
ws.Map(serverPath, localPath);
return(ws);
}
catch (Exception e)
{
e.Error();
}
return(null);
};
// get the workspaces for this user on this machine and their working folders, if any, for the project collection they belong to
var pcsAndAllTheirWorkspaces =
from pc in lpc.AsParallel()
let vcs = pc.GetService <VersionControlServer>()
let localPath = pc.GetProjectCollectionLocalPath(Globals.TfsRoot)
select new
{
LocalPath = localPath,
VersionControlServer = vcs,
ProjectCollection = pc,
WorkspaceAndWorkingFolderList = vcs
.QueryWorkspaces(null, vcs.AuthorizedUser, null)
.Where(workspace => workspace.Computer.Equals(Environment.MachineName, StringComparison.OrdinalIgnoreCase))
.Select(workspace => Tuple.Create(workspace, workspace.TryGetWorkingFolderForLocalItem(localPath)))
};
$"{nameof(pcsAndAllTheirWorkspaces)}: {string.Join(",", pcsAndAllTheirWorkspaces.Select(arg => arg.LocalPath))}".Trace();
$"{nameof(pcsAndAllTheirWorkspaces)}: {string.Join(",", pcsAndAllTheirWorkspaces.Select(arg => arg.WorkspaceAndWorkingFolderList.Count()))}".Trace();
// select the relevant information from the above gross and create workspace and mapping where necessary
var pcsAndMappedWorkspaces =
from a in pcsAndAllTheirWorkspaces
let workspaceAndFolder = a.WorkspaceAndWorkingFolderList.SingleOrDefault(tuple => tuple.Item2 != null)
let name = workspaceAndFolder?.Item1.Name ?? workspaceName(a.ProjectCollection)
let workspace = workspaceAndFolder?.Item1 ?? mapWorkspace(createWorkSpace(a.VersionControlServer, name), a.ProjectCollection)
let workingFolder = workspaceAndFolder?.Item2 ?? workspace.TryGetWorkingFolderForLocalItem(a.LocalPath)
select new
{
a.ProjectCollection,
a.VersionControlServer,
Workspace = workspace,
WorkingFolder = workingFolder
};
$"{nameof(pcsAndMappedWorkspaces)}: {string.Join(",", pcsAndMappedWorkspaces.Select(arg => arg.WorkingFolder.LocalItem))}".Trace();
var allProjects =
from p in pcsAndMappedWorkspaces
from pp in p.ProjectCollection.GetTeamProjects()
let sp = pp.GetProjectServerPath(p.ProjectCollection)
let wf = p.Workspace.TryGetWorkingFolderForServerItem(sp)
where wf.LocalItem.ToLowerInvariant().Contains(Configuration.SourceRoot.ToLowerInvariant())
select new
{
ProjectCollection = p,
Project = pp,
LocalPath = pp.GetProjectLocalPath(p.ProjectCollection),
ServerPath = sp,
WorkspaceInfo = p.Workspace,
WorkingFolder = wf
};
$"{nameof(allProjects)}: {string.Join(",", allProjects.Select(arg => arg.LocalPath))}".Trace();
var filterStats = new Dictionary <StatTypes, int>
{
[StatTypes.Added] = 0,
[StatTypes.Deleted] = 0,
[StatTypes.Ignored] = 0,
[StatTypes.Skipped] = 0
};
string[] exceptions = { @"vnext", @"-oem" };
string[] exclusions = { @"/development/", @"/release/", @"/team/" };
var maxAge = TimeSpan.FromHours(6.0);
var fc = new GetFilterCallback((Workspace workspace,
ILocalUpdateOperation[] operations,
object userData) =>
{
var spec = userData as ItemSpec;
$"TFS filter callback: workspace name = {workspace.Name} | spec.item = {spec.Item} | number of operations {operations.Length}".Trace();
foreach (var operation in operations)
{
if (
operation.TargetServerItem != null &&
exclusions.Any(s1 => operation.TargetServerItem.ToLowerInvariant().Contains(s1)) &&
!exceptions.Any(s2 => operation.TargetServerItem.ToLowerInvariant().Contains(s2)))
{
operation.Ignore = true;
filterStats[StatTypes.Skipped]++;
}
if (
operation.SourceLocalItem != null &&
File.Exists(operation.SourceLocalItem) &&
(DateTime.UtcNow - File.GetLastWriteTimeUtc(operation.SourceLocalItem) < maxAge)
)
{
filterStats[StatTypes.Skipped]++;
operation.Ignore = true;
}
if (operation.TargetLocalItem == null)
{
filterStats[StatTypes.Deleted]++;
}
filterStats[StatTypes.Added]++;
}
});
$"Getting all files from {allProjects.Count()} projects".Trace();
// get all the files
allProjects.AsParallel().WithDegreeOfParallelism(1).ForAll(obj =>
{
var subs = obj.ProjectCollection.VersionControlServer.GetItems($"{obj.WorkingFolder.ServerItem}/*");
for (int i = 0; i < subs.Items.Length; i++)
{
foreach (var ext in Extensions)
{
$"get files: {nameof(ext)} = {ext}".Trace();
var pattern = $"{subs.Items[i].ServerItem}/*.{ext}";
var itemSpec = new ItemSpec(pattern, RecursionType.Full);
var getRequest = new GetRequest(itemSpec, VersionSpec.Latest);
$"get files: {nameof(pattern)} = {pattern}".Trace();
$"get files: {nameof(itemSpec)} = {itemSpec.Item}".Trace();
try
{
obj.WorkspaceInfo.Get(getRequest, GetOptions.GetAll, fc, itemSpec);
}
catch (Exception e)
{
e.Error();
}
}
}
});
sw.Stop();
$"Finished get info for all TPCs and all projects. Time elapsed: {sw.ElapsedMilliseconds.ToString("F")}".Info();
}
catch (Exception e)
{
e.Error();
throw;
}
}
