Comment créer une branche de Visual Source Safe utilisant NAnt

Question

Résumé J'ai actuellement un script de construction de NAnt qui effectue une vssget soit sur le dernier code source, ou d'une branche spécifique (en utilisant un paramètre ${branch}).

Chaque fois que nous faisons une version de production / déploiement du code arbre qui a été construit a créé une branche, (afin que nous puissions poursuivre le développement et le savoir encore ce code de base est sur la production, à peu des choses standards ...)

Problème Le processus de création de cette branche est encore un manuel, réalisé par quelqu'un d'entrer dans de Visual Source Safe Explorer et d'exécuter la procédure de branchement. Je me demandais s'il y a une façon NAnt de créer une branche de VSS.

Régime actuel Je sais déjà sur l'utilisation <exec program="ss"> et essaie d'éviter, mais en l'absence de meilleures solutions, qui est la route la plus probable que je prendrai.

Est-ce que quelqu'un sait s'il y a un NAnt ou cible NAntContrib pour cela, ou si quelqu'un a une tâche de script qu'ils ont utilisé pour ce faire dans le passé et pourrait fournir le code pour cela, ce serait très apprécié.

Disclaimer Je sais à propos cvs, svn, git et toutes les autres solutions de contrôle Source, et de changer l'outil n'est pas une option à l'heure actuelle

Answer 1

Nous avons besoin de ce fait où je travaille. Je fouetté ensemble une petite tâche appelée « vssbranch » (pas particulièrement créatif, mais voici le code ... un fichier de construction exemple et la sortie de son exécution:

CODE:

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;

using SourceSafeTypeLib;

using NAnt.Core;
using NAnt.Core.Attributes;

namespace NAnt.Contrib.Tasks.SourceSafe
{
    [TaskName("vssbranch")]
    public sealed class BranchTask : BaseTask
    {
        /// <summary>
        /// The label comment.
        /// </summary>
        [TaskAttribute("comment")]
        public String Comment { get; set; }

        /// <summary>
        /// Determines whether to perform the branch recursively.
        /// The default is <see langword="true"/>
        /// </summary>
        [TaskAttribute("recursive"),
        BooleanValidator()]
        public Boolean Recursive { get; set; }

        [TaskAttribute("branchname", Required = true)]
        public String BranchName { get; set; }


        protected override void ExecuteTask()
        {
            this.Open();
            try
            {
                if (VSSItemType.VSSITEM_PROJECT != (VSSItemType)this.Item.Type)
                    throw new BuildException("Only vss projects can be branched", this.Location);

                IVSSItem newShare = null;
                this.Comment = String.IsNullOrEmpty(this.Comment) ? String.Empty : this.Comment;
                if (null != this.Item.Parent)
                    newShare = this.Item.Parent.NewSubproject(this.BranchName, this.Comment);

                if (null != newShare)
                {
                    newShare.Share(this.Item as VSSItem, this.Comment,
                        (this.Recursive) ?
                            (int)VSSFlags.VSSFLAG_RECURSYES : 0);
                    foreach (IVSSItem item in newShare.get_Items(false))
                        this.BranchItem(item, this.Recursive);
                }
            }
            catch (Exception ex)
            {
                throw new BuildException(String.Format("Failed to branch '{0}' to '{1}'", this.Item.Name, this.BranchName), this.Location, ex);
            }
        }

        private void BranchItem(IVSSItem itemToBranch, Boolean recursive)
        {
            if (null == itemToBranch) return;

            if (this.Verbose)
                this.Log(Level.Info, String.Format("Branching {0} path: {1}", itemToBranch.Name, itemToBranch.Spec));

            if (VSSItemType.VSSITEM_FILE == (VSSItemType)itemToBranch.Type)
                itemToBranch.Branch(this.Comment, 0);
            else if (recursive)
            {
                foreach (IVSSItem item in itemToBranch.get_Items(false))
                    this.BranchItem(item, recursive);
            }
        }
    }
}

FICHIER BUILD:

                                                             

        <echo message="About to execute: VSS Branch" />

        <echo message="Source Safe Path: ${SourceSafeRootPath}/${CURRENT_FILE}" />

        <vssbranch
              username="my_user_name"
              password="my_password"
              recursive="true"
              comment="attempt to make a branch"
              branchname="test-branch"
              dbpath="${SourceSafeDBPath}"
              path="${SourceSafeRootPath}/${CURRENT_FILE}"
              verbose="true"
            />

    </foreach>
</target>

SORTIE:

NAnt 0,85 (Const 0.85.2478.0; libération; 10/14/2006) Copyright (C) 2001-2006 Gerry Shaw http://nant.sourceforge.net

Buildfile: file: /// C: /scm/custom/src/VssBranch/bin/Debug/test.build cadre cible: Microsoft .NET Framework 2.0 (S) cible spécifiée: run

run:

[loadtasks] analyse "assemblage NAnt.Contrib.Tasks" pour les extensions. [Loadtasks] assemblage à balayage "VssBranch" pour les extensions.      [Echo] A propos de l'exécution: Direction VSS

....

[vssbranch] Branching chemin SecurityProto: $ / VSS / Endur Source / C # / DailyLive / proto / test-branche / SecurityProto

....

BUILD RÉUSSI

Durée totale:. 12,9 secondes

Il est évident que la sortie varie, je tirais dans les articles à la branche d'un fichier texte nommé « params.txt ». Cette tâche exécute ce qui est connu dans le monde de VSS comme « Partager et de la » (Branching immédiatement après le partage) ... d'autres systèmes de contrôle de source ne sont pas besoin de partager avant de bifurquer, eh ... qui est pour un autre jour

Answer 2

Les tâches de vss vivent dans le projet NAntContrib et non, il n'y a actuellement aucune tâche supports de branchement. Bien que, suivant le modèle des tâches existantes vss (add, achat, checkin, etc.) dans NAntContrib, vous pourriez saisir source et étendre vous-même. C'est, si les supports de l'API VSS de branchement.