/// <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 override bool Execute() { Workspace workspace; VersionControlServer versionControlServer; GetServices(out workspace, out versionControlServer); if (workspace == null || versionControlServer == null) { return(false); } VersionSpec spec = new WorkspaceVersionSpec(workspace); IEnumerable history = versionControlServer.QueryHistory(LocalPath, spec, 0, RecursionType.Full, null, null, null, 1, false, false); IEnumerator historyEnumerator = history.GetEnumerator(); if (historyEnumerator.MoveNext()) { Log.LogMessage(MessageImportance.Normal, "Found history entry"); var cs = historyEnumerator.Current as Changeset; Log.LogMessage(MessageImportance.Normal, "changeset id: " + cs.ChangesetId); _changeset = cs.ChangesetId; } return(true); }
public override void Run() { string path = Environment.CurrentDirectory; if (Arguments.Length > 0) { path = Path.GetFullPath(Arguments[0]); } char[] charsToTrim = { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar }; string fxdPath = path.TrimEnd(charsToTrim); string itemPath = Path.Combine(path, "*"); Workspace workspace = GetWorkspaceFromCache(); workspace.RefreshMappings(); string serverPath = workspace.GetServerItemForLocalItem(fxdPath); // pull item list based on WorkspaceVersion. otherwise might get // new items on server that haven't been pulled yet in the list returned WorkspaceVersionSpec version = new WorkspaceVersionSpec(workspace); // process command options ItemSpec itemSpec = new ItemSpec(itemPath, RecursionType.Full); ItemSet itemSet = VersionControlServer.GetItems(itemSpec, version, DeletedState.NonDeleted, ItemType.Any, true); Item[] items = itemSet.Items; SortedList <string, bool> itemList = new SortedList <string, bool>(PathComparer); foreach (Item item in items) { string serverItem = item.ServerItem.Remove(0, serverPath.Length + 1); string fname = Path.Combine(path, serverItem); //Console.WriteLine(serverItem + " : " + fname); itemList.Add(fname, true); } DirectoryInfo dir = new DirectoryInfo(path); foreach (FileInfo file in dir.GetFiles("*", SearchOption.AllDirectories)) { if (!itemList.ContainsKey(file.FullName)) { if (OptionPreview) { Console.WriteLine(file.FullName); } else { DeleteReadOnlyFile(file.FullName); } } } }
private void ProcessFileList(SortedList <string, bool> files) { List <ItemSpec> itemSpecs = new List <ItemSpec>(); foreach (string file in files.Keys) { itemSpecs.Add(new ItemSpec(file, RecursionType.None)); } // pull item list based on WorkspaceVersion. otherwise might get // new items on server that haven't been pulled yet in the list returned WorkspaceVersionSpec version = new WorkspaceVersionSpec(workspace); SortedList <string, byte[]> itemList = new SortedList <string, byte[]>(PathComparer); // get item list from TFS server ItemSet[] itemSets = VersionControlServer.GetItems(itemSpecs.ToArray(), version, DeletedState.NonDeleted, ItemType.File, true); foreach (ItemSet itemSet in itemSets) { foreach (Item item in itemSet.Items) { string localItem = workspace.GetLocalItemForServerItem(item.ServerItem); itemList.Add(localItem, item.HashValue); } } // process adds and edits foreach (string file in files.Keys) { // skip files we're not interested in here if (IsExcludedFile(file)) { continue; } if (!File.Exists(file)) { if (OptionDeleted && itemList.ContainsKey(file)) { Console.WriteLine("Deleted: " + file); deletedFiles.Add(file); } continue; } ProcessFile(itemList, file); } }
// Fill in the workspace name if it is null. static VersionSpec ParseVersionSpec(String spec, Workspace workspace) { String user = workspace.VersionControlServer.TeamFoundationServer.AuthenticatedUserName; VersionSpec version = VersionSpec.ParseSingleSpec(spec, user); // If the user happened to specify only W for the workspace spec, we'll have to // fill in the workspace here (the parse method doesn't know it). WorkspaceVersionSpec wvs = version as WorkspaceVersionSpec; if (wvs != null && wvs.Name == null) { wvs.Name = workspace.Name; } return(version); }
public void TestIncomingCommand() { TfsTask task = CreateTfsTaskFromLocalProjectPath(TFSServerAddress, this.testProjectPath); var history2 = task.VersionControlServer.QueryHistory(task.ProjectPath, new WorkspaceVersionSpec(task.Workspace), 0, RecursionType.Full, null, new WorkspaceVersionSpec(task.Workspace), null, 10, true, true).Cast <Changeset>().ToList(); var w = new WorkspaceVersionSpec(task.Workspace); var history3 = task.VersionControlServer.QueryHistory(new QueryHistoryParameters(task.ProjectPath, RecursionType.Full) { VersionEnd = w, MaxResults = 1 }).Cast <Changeset>().ToArray(); var history5 = task.VersionControlServer.QueryHistory(new QueryHistoryParameters(task.ProjectPath, RecursionType.Full) { VersionStart = new ChangesetVersionSpec(history3[0].ChangesetId + 1), VersionEnd = VersionSpec.Latest }).Cast <Changeset>().ToArray(); }
static int Main(string[] args) { try { Console.InputEncoding = Encoding.UTF8; Console.OutputEncoding = Encoding.UTF8; if (args.Length != 0) { Console.Error.WriteLine("This program is only expected to be called by the SonarQube TFS SCM plugin."); return(1); } Console.WriteLine("Enter your credentials"); Console.Out.Flush(); var username = Console.ReadLine(); var password = Console.ReadLine(); var pat = Console.ReadLine(); TfsClientCredentials credentials; if (!String.IsNullOrEmpty(pat)) { credentials = new TfsClientCredentials(new BasicAuthCredential(new NetworkCredential("", pat))); } else if (!String.IsNullOrEmpty(username) || !String.IsNullOrEmpty(password)) { credentials = new TfsClientCredentials(new WindowsCredential(new NetworkCredential(username, password))); } else { credentials = new TfsClientCredentials(true); } credentials.AllowInteractive = false; Console.WriteLine("Enter the Collection URI"); Console.Out.Flush(); var serverUriString = Console.ReadLine(); if (!string.IsNullOrEmpty(serverUriString)) { if (!SetServerUri(serverUriString)) { return(1); } } using (var cache = new TfsCache(credentials)) { if (serverUri != null) { if (!UpdateCache(cache, serverUri)) { return(1); } } Console.Out.WriteLine("Enter the paths to annotate"); Console.Out.Flush(); string path; while ((path = Console.ReadLine()) != null) { try { Console.Out.Flush(); Console.WriteLine(path); if (!File.Exists(path)) { FailOnFile("does not exist: " + path); continue; } if (!Workstation.Current.IsMapped(path)) { FailOnFile("is not in a mapped TFS workspace: " + path); continue; } WorkspaceInfo workspaceInfo = Workstation.Current.GetLocalWorkspaceInfo(path); WorkspaceVersionSpec version = new WorkspaceVersionSpec(workspaceInfo); if (serverUri == null || workspaceInfo.ServerUri.AbsoluteUri != serverUri.AbsoluteUri) { serverUri = workspaceInfo.ServerUri; if (!UpdateCache(cache, serverUri)) { return(1); } } var versionControlServer = cache.GetVersionControlServer(serverUri); IAnnotatedFile annotatedFile = new FileAnnotator(versionControlServer).Annotate(path, version); if (annotatedFile == null) { FailOnFile("is not yet checked-in: " + path); continue; } if (annotatedFile.IsBinary()) { FailOnFile("is a binary one: " + path); continue; } bool failed = false; for (int i = 0; !failed && i < annotatedFile.Lines(); i++) { var state = annotatedFile.State(i); if (state != AnnotationState.COMMITTED) { FailOnFile("line " + (i + 1) + " has not yet been checked-in (" + state + "): " + path); failed = true; } } if (failed) { continue; } Console.WriteLine(annotatedFile.Lines()); for (int i = 0; i < annotatedFile.Lines(); i++) { Changeset changeset = annotatedFile.Changeset(i); Console.Write(changeset.ChangesetId); Console.Write('\t'); Console.Write(cache.GetEmailOrAccountName(serverUri, changeset.Owner)); Console.Write('\t'); Console.Write(ToUnixTimestampInMs(changeset.CreationDate)); Console.Write('\t'); Console.WriteLine(annotatedFile.Data(i)); } } catch (Exception e) { FailOnFile(e.Message); } } Console.Out.Flush(); } return(0); } catch (Exception e) { FailOnProject(e.Message); return(1); } }
/// <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; }
static int Main(string[] args) { if (args.Length == 0) { Console.Error.WriteLine("Expected exactly one argument, the file to annotate. " + args.Length + " given."); return(1); } String path = args[args.Length - 1]; if (!File.Exists(path)) { Console.Error.WriteLine("The given file does not exist: " + path); return(2); } if (!Workstation.Current.IsMapped(path)) { Console.Error.WriteLine("The given file is not in a mapped TFS workspace: " + path); return(3); } WorkspaceInfo workspaceInfo = Workstation.Current.GetLocalWorkspaceInfo(path); Uri serverUri = workspaceInfo.ServerUri; WorkspaceVersionSpec version = new WorkspaceVersionSpec(workspaceInfo); TfsClientCredentials credentials = new TfsClientCredentials(true); using (TfsTeamProjectCollection collection = new TfsTeamProjectCollection(serverUri, credentials)) { VersionControlServer server = collection.GetService <VersionControlServer>(); IAnnotatedFile annotatedFile = new FileAnnotator(server).Annotate(path, version); if (annotatedFile == null) { Console.Error.WriteLine("The given file has not yet been checked-in: " + path); return(4); } if (annotatedFile.IsBinary()) { Console.Error.WriteLine("The given file is a binary one: " + path); return(5); } for (int i = 0; i < annotatedFile.Lines(); i++) { switch (annotatedFile.State(i)) { case AnnotationState.UNKNOWN: Console.Write("unknown "); break; case AnnotationState.LOCAL: Console.Write("local "); break; case AnnotationState.COMMITTED: Changeset changeset = annotatedFile.Changeset(i); Console.Write(changeset.ChangesetId); Console.Write(' '); Console.Write(changeset.Owner); Console.Write(' '); Console.Write(changeset.CreationDate.ToString("MM\\/dd\\/yyyy")); Console.Write(' '); break; default: throw new InvalidOperationException("Unsupported annotation state: " + annotatedFile.State(i)); } Console.WriteLine(annotatedFile.Data(i)); } } return(0); }
private void ProcessDirectory(string path) { char[] charsToTrim = { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar }; string itemPath = path.TrimEnd(charsToTrim); string serverPath = workspace.GetServerItemForLocalItem(itemPath); // pull item list based on WorkspaceVersion. otherwise might get // new items on server that haven't been pulled yet in the list returned WorkspaceVersionSpec version = new WorkspaceVersionSpec(workspace); // process recursion settings RecursionType rtype = OptionRecursive ? RecursionType.Full : RecursionType.OneLevel; bool recursionSetting = Settings.Current.GetAsBool("Online.Recursive"); if (recursionSetting) { rtype = RecursionType.Full; } SearchOption searchType = (rtype == RecursionType.Full) ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly; // process command options ItemSpec itemSpec = new ItemSpec(itemPath, rtype); ItemSet itemSet = VersionControlServer.GetItems(itemSpec, version, DeletedState.NonDeleted, ItemType.Any, true); // get item list from TFS server Item[] items = itemSet.Items; SortedList <string, byte[]> itemList = new SortedList <string, byte[]>(PathComparer); foreach (Item item in items) { if (item.ServerItem.Length == serverPath.Length) { continue; } string serverItem = item.ServerItem.Remove(0, serverPath.Length + 1); // server item paths are separated with '/', but on windows the file list below has '\' separated paths if (Path.DirectorySeparatorChar != '/') { serverItem = serverItem.Replace('/', Path.DirectorySeparatorChar); } string fname = Path.Combine(itemPath, serverItem); //Console.WriteLine(serverItem + " : " + fname); itemList.Add(fname, item.HashValue); } DirectoryInfo dir = new DirectoryInfo(path); FileInfo[] localFiles = dir.GetFiles("*", searchType); SortedList <string, bool> dirList = new SortedList <string, bool>(); foreach (FileInfo file in localFiles) { // skip files we're not interested in if (IsExcludedFile(file.FullName)) { continue; } dirList.Add(file.FullName, true); ProcessFile(itemList, file.FullName); } foreach (DirectoryInfo di in dir.GetDirectories("*", SearchOption.AllDirectories)) { dirList.Add(di.FullName, true); } if (!OptionDeleted) { return; } foreach (string key in itemList.Keys) { // skip files that exist or we're not interested in if (dirList.ContainsKey(key)) { continue; } if (IsExcludedFile(key)) { continue; } Console.WriteLine("Deleted: " + key); deletedFiles.Add(key); } }
public override void Run() { string path = Environment.CurrentDirectory; if (Arguments.Length > 0) { path = Path.GetFullPath(Arguments[0]); } if (File.Exists(path)) { // would need to fixup dir.GetDirectories calls if we wanted to support filenames Console.WriteLine("Error: This command only takes paths as arguments, not file names."); Environment.Exit((int)ExitCode.Failure); } char[] charsToTrim = { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar }; string itemPath = path.TrimEnd(charsToTrim); if (OptionWritable) { ShowWritableFiles(itemPath); Environment.Exit((int)ExitCode.Success); } Workspace workspace = GetWorkspaceFromCache(); workspace.RefreshMappings(); string serverPath = workspace.GetServerItemForLocalItem(itemPath); // process command options ItemSpec itemSpec = new ItemSpec(itemPath, RecursionType.Full); if (OptionOld) { ShowOldFiles(workspace, itemSpec); Environment.Exit((int)ExitCode.Success); } // pull item list based on WorkspaceVersion. otherwise might get // new items on server that haven't been pulled yet in the list returned WorkspaceVersionSpec version = new WorkspaceVersionSpec(workspace); ItemSet itemSet = VersionControlServer.GetItems(itemSpec, version, DeletedState.NonDeleted, ItemType.Any, true); Item[] items = itemSet.Items; SortedList <string, string> itemList = new SortedList <string, string>(PathComparer); foreach (Item item in items) { if (item.ServerItem.Length == serverPath.Length) { continue; } string serverItem = item.ServerItem.Remove(0, serverPath.Length + 1); // server item paths are separated with '/', but on windows the file list below has '\' separated paths if (Path.DirectorySeparatorChar != '/') { serverItem = serverItem.Replace('/', Path.DirectorySeparatorChar); } string fname = Path.Combine(itemPath, serverItem); string hash = ""; if (item.ItemType == ItemType.File && item.HashValue != null) { hash = Convert.ToBase64String(item.HashValue); } itemList.Add(fname, hash); } if (OptionOthers) { ShowOtherFiles(itemPath, itemList); } else if (OptionDeleted) { ShowDeletedFiles(itemPath, itemList); } else if (OptionModified) { ShowModifiedFiles(itemPath, itemList); } else { foreach (string key in itemList.Keys) { Driver.WriteLine(key); } } }
public void ShowModifiedFiles(Workspace workspace, string path) { char[] charsToTrim = { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar }; string itemPath = path.TrimEnd(charsToTrim); workspace.RefreshMappings(); string serverPath = workspace.GetServerItemForLocalItem(itemPath); // pull item list based on WorkspaceVersion. otherwise might get // new items on server that haven't been pulled yet in the list returned WorkspaceVersionSpec version = new WorkspaceVersionSpec(workspace); // get item list from TFS server ItemSpec itemSpec = new ItemSpec(itemPath, RecursionType.Full); ItemSet itemSet = VersionControlServer.GetItems(itemSpec, version, DeletedState.NonDeleted, ItemType.Any, true); Item[] items = itemSet.Items; foreach (Item item in items) { if (item.ItemType != ItemType.File) { continue; } if (item.ServerItem.Length == serverPath.Length) { continue; } string serverItem = item.ServerItem.Remove(0, serverPath.Length + 1); // server item paths are separated with '/', but on windows the file list below has '\' separated paths if (Path.DirectorySeparatorChar != '/') { serverItem = serverItem.Replace('/', Path.DirectorySeparatorChar); } // only looking for modifications, not deletes or adds string fname = Path.Combine(itemPath, serverItem); if (!File.Exists(fname)) { continue; } if (FileAttributes.ReadOnly == (File.GetAttributes(fname) & FileAttributes.ReadOnly)) { continue; } using (FileStream fileStream = new FileStream(fname, FileMode.Open, FileAccess.Read)) { string localHash = Convert.ToBase64String(md5.ComputeHash(fileStream)); string itemHash = Convert.ToBase64String(item.HashValue); if (itemHash == localHash) { continue; } } string p = fname.Substring(path.Length + 1); if (OptionBrief) { Driver.WriteLine(CanonicalPath(p)); continue; } string tnameA = Path.GetTempFileName(); item.DownloadFile(tnameA); IDiffItem a = new DiffItemLocalFile(tnameA, item.Encoding, DateTime.Now, false); IDiffItem b = new DiffItemLocalFile(fname, item.Encoding, DateTime.Now, false); Difference.DiffFiles(VersionControlServer, a, b, GetDiffOptions(), p, true); if (!String.IsNullOrEmpty(tnameA)) { File.Delete(tnameA); } } }