Programatically find TFS changes since last build

Question

Tengo varias ramas en TFS (desarrollo, prueba, etapa) y cuando fusiono los cambios en la rama de prueba, quiero que la secuencia de comandos automatizada de compilación e implementación encuentre todos los archivos SQL actualizados e implemente ellos a la base de datos de prueba.

Pensé que podría hacer esto al encontrar todos los conjuntos de cambios asociados con la compilación desde la última compilación, encontrar todos los archivos sql en los conjuntos de cambios y desplegarlos. Sin embargo, parece que no estoy teniendo el conjunto de cambios asociado con la construcción por alguna razón, por lo que mi pregunta es doble:

1) ¿Cómo me aseguro de que un conjunto de cambios esté asociado con una compilación en particular?

2) ¿Cómo puedo obtener una lista de los archivos que han cambiado en la rama desde la última compilación? Tengo la última compilación construida con éxito, pero no estoy seguro de cómo obtener los archivos sin verificar los conjuntos de cambios (que como se mencionó anteriormente no están asociados con la compilación!)

Answer 1

Gracias Scott,

Después de un tiempo me encontré una buena manera de manejar esto.

Básicamente creé una tarea que obtiene los conjuntos de cambios actuales asociados con la compilación (el punto 1 de mi pregunta no es un problema) y luego recorro en busca de archivos .sql. Una vez que tengo una lista de ellos, puedo crear un script de cambio o ejecutarlos en la base de datos de destino.

El código es como la siguiente:

TeamFoundationServer tfs = new TeamFoundationServer(TfsServerUrl); 
VersionControlServer vcs = (VersionControlServer)tfs.GetService(typeof(VersionControlServer)); 

var buildServer = (IBuildServer)tfs.GetService(typeof(IBuildServer)); 


IBuildDetail build = buildServer.GetBuild(
    new Uri(BuildUri) 
    , null 
    , QueryOptions.All 
); 

build.RefreshAllDetails(); 

var changesets = InformationNodeConverters.GetAssociatedChangesets(build); 

foreach (var changesetSummary in changesets) 
{ 
    Changeset changeSet = vcs.GetChangeset(changesetSummary.ChangesetId); 

    sqlFilePaths.AddRange(
     ProcessChangeSet(changeSet) 
    ); 

} 

y el código dentro ProcessChangeSet parece

List<string> sqlFilePaths = new List<string>(); 
foreach (Change change in changeSet.Changes) 
{ 

    if ((change.Item.ItemType == ItemType.File) 
     && (change.Item.ServerItem.EndsWith(".sql", StringComparison.OrdinalIgnoreCase)) 
     ) 
    { 
     sqlFilePaths.Add(
      sqlPath 
     ); 

    } 
} 
return sqlFilePathes; 

Pero si alguien quiere estoy feliz de darles el código completo. Asegura que los procedimientos almacenados estén sincronizados en todo el sistema. Esto solo deja cambios de esquema para administrar manualmente dentro de mi base de datos, lo que me complace hacer.

Answer 2

Así que puedo entender el atractivo intuitivo de este enfoque, pero No creo que sea la forma correcta de hacerlo.

Por un lado, va a ser difícil. Pero el segundo problema es que TFS no tiene una buena manera de registrar datos de implementación.

Para la primera pregunta, no estoy seguro de lo que eso significa. Para la segunda pregunta, puede usar las etiquetas de compilación y la lista de historial de hoy de los archivos modificados.

Como alternativa, podría reconsiderar cómo desea administrar los cambios de SQL. Utilizo un método de baja tecnología para mantener los cambios pendientes actuales en un directorio, y luego de implementar moviendo los archivos a un directorio diferente. Este método se puede mejorar manteniendo una tabla de historial de despliegue en la base de datos. También es posible que desee buscar en vsts DB además, el actual CTP tiene muchas características nuevas sobre la administración de cambios en la base de datos. También escuché que Red Gate tiene buenas herramientas de administración de bases de datos también.