Beispiel #1
0
    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);
                    }
            }
    }
        /// <summary>
        /// Generates a version part which matches the current change set of the working copy being patched
        /// </summary>
        /// <param name="currentPartValue">The current value of the version part - this value is not used by this
        /// generator</param>
        /// <param name="ctx">The version part generation context</param>
        /// <returns>The TFS change set number for the current working copy being patched</returns>
        public int Generate(int currentPartValue, VersionPartPatchingContext ctx)
        {
            // The workspace info for the provided path

            var wsInfo = Workstation.Current.GetLocalWorkspaceInfo(ctx.SolutionRootPath);

            if(wsInfo == null)
                throw new InvalidOperationException(string.Format("The target solution and project must be a TFS working copy - {0}", ctx));

            // Get the TeamProjectCollection and VersionControl server associated with the
            // WorkspaceInfo

            var tpc = new TfsTeamProjectCollection(wsInfo.ServerUri);
            var vcServer = tpc.GetService<VersionControlServer>();

            // Now get the actual Workspace OM object

            var ws = vcServer.GetWorkspace(wsInfo);

            // We are interested in the current version of the workspace

            var versionSpec = new WorkspaceVersionSpec(ws);

            var historyParams = new QueryHistoryParameters(ctx.SolutionRootPath, RecursionType.Full)
            {
                ItemVersion = versionSpec,
                VersionEnd = versionSpec,
                MaxResults = 1
            };

            // return changeset

            var changeset = vcServer.QueryHistory(historyParams).FirstOrDefault();
            if (changeset != null) return changeset.ChangesetId;

            // no changeset found.

            throw new InvalidOperationException(string.Format("Could not find changeset values for solution path \"{0}\"", ctx.SolutionRootPath));
        }
Beispiel #3
0
        static int Main(string[] args)
        {
            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();

            TfsClientCredentials credentials;
            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)
                {
                    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));
                    }
                }
                Console.Out.Flush();
            }

            return 0;
        }
Beispiel #4
0
        public void WorkspaceVersionSpec()
        {
            VersionSpec spec = new WorkspaceVersionSpec("name", "owner");

            Assert.AreEqual("Wname;owner", spec.DisplayString);
        }
Beispiel #5
0
        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 static Changeset GetChangeset(IBuildDetail buildDetail, Workspace workspace, IBuildAgent buildAgent)
        {
            var workspaceSourcePath = Path.Combine(buildAgent.GetExpandedBuildDirectory(buildDetail.BuildDefinition), "Sources");

            var versionSpec = new WorkspaceVersionSpec(workspace);

            var historyParams = new QueryHistoryParameters(workspaceSourcePath, RecursionType.Full)
            {
                ItemVersion = versionSpec,
                VersionEnd = versionSpec,
                MaxResults = 1
            };

            var changeset = workspace.VersionControlServer.QueryHistory(historyParams).FirstOrDefault();
            return changeset;
        }
Beispiel #7
0
    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);
            }
    }
Beispiel #8
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);
            }
    }