Cómo crear una rama utilizando Visual Source Safe de NAnt

Question

Resumen
Actualmente tengo un script de construcción NAnt que realiza una vssget ya sea en el último código fuente, o una rama específica (usando un parámetro ${branch}).

Siempre que hacemos una producción build / implementación del código de árboles que se construyó ha creado una rama, (para que podamos continuar con el desarrollo y todavía saber qué código base está en la producción, bastante cosas estándar ...)

Problema:
El proceso de creación de esa rama sigue siendo uno manual, realizado por alguien entrar en Visual Source Explorer seguro y realizar el procedimiento de ramificación. Me preguntaba si hay alguna manera en NAnt de crear una rama de VSS.

Plan de corriente
Ya sé acerca del uso de <exec program="ss"> y estoy tratando de evitar eso, pero en ausencia de cualquier solución mejor, que es la ruta más probable que voy a tomar.

¿Alguien sabe si hay un objetivo NAnt o NAntContrib para esto, o si alguien tiene una tarea secuencia de comandos que se han utilizado para hacer esto en el pasado y podrían proporcionar el código para eso, que sería muy apreciada.

Aviso Legal
lo que sé de CVS, SVN, Git y todas las otras soluciones de control de origen, y para cambiar la herramienta no es una opción en la actualidad

Answer 1

necesitamos en realidad en la que trabajo. Azoté juntos una pequeña tarea llamada 'vssbranch' (no particularmente creativa, pero aquí está el código ... un fichero de construcción ejemplo y la salida de su ejecución:

CÓDIGO:

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);
            }
        }
    }
}

fichero de construcción:

                                                             

        <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>

Salida:

de NAnt 0.85 (Build 0.85.2478.0; liberación; 10/14/2006) Copyright (C) 2001-2006 Gerry Shaw http://nant.sourceforge.net

Buildfile: file: /// C: /scm/custom/src/VssBranch/bin/Debug/test.build marco de destino: Microsoft .NET Framework 2.0 Objetivo (s) específico: plazo

Ejecutar:

[loadtasks] de exploración de montaje "NAnt.Contrib.Tasks" para extensiones. [Loadtasks] Scanning montaje "VssBranch" de las extensiones.      [Echo] a punto de ejecutar: VSS Branch

....

[vssbranch] ruta de ramificación SecurityProto: $ / VSS / Fuente de Endur / C # / DailyLive / proto / test-rama / SecurityProto

....

BUILD SUCCEEDED

Un total de tiempo:. 12,9 segundos

Es evidente que la salida podría variar, estaba tirando de los elementos que se ramifican desde un archivo de texto llamado 'params.txt'. Esto realiza la tarea lo que se conoce en el mundo como VSS 'Compartir y Poder' (ramificación inmediatamente después de compartir) ... otros sistemas de control de origen no necesitan acción antes de ramificación, eh ... eso es para otro día

Answer 2

Las tareas de VSS viven en el proyecto NAntContrib y no, actualmente no hay ninguna tarea que los soportes de ramificación. Aunque, siguiendo el modelo de las tareas existentes VSS (ADD, pago y envío, registro, etc.) en NAntContrib, usted podría agarrar la fuente y extenderlo a sí mismo. Es decir, si admitido por la API de VSS de ramificación.