Génération automatique d'une version d'éxecutable

Bonjour à tous,

J'utilise SVN avec Tortoise SVN pour le mode graphique, le tout sous Windows XP.
Les projets que je développe et qui sont sur le SVN sont en C# développé avec Visual Studio 2005.

Voila ma question :
J'aimerais savoir s'il y a moyen de créer un script permettant de générer un exécutable à partir d'une version "taguée" d'un projet dans SVN ?
L'idée serait d'avoir un script qui puisse accélérer grandement la création d'un exécutable plutôt que de tout faire manuellement : télécharger le référentiel dans une copie de travail sur son poste et lancer Visual (en ligne de commande ou non) pour compiler les sources.
Je sais que je pourrai également tagué l'exécutable dans le SVN et d'ailleurs c'est ce que je fais, mais j'ai envie d'avoir aussi ce script à disposition.

Merci d'avance pour votre aide.

Joachim.

http://defaut.developpez.com/tutorie...cruisecontrol/

Merci pour ta réponse S.levon, mais ce n'est pas tout à fait ce que je souhaite faire.
L'intégration continue génère un build (avec tests unitaires) de l'application à chaque fois qu'il y a une modification des sources. Mon besoin ce n'est pas de l'intégration continue.
Je souhaite juste pouvoir générer un build à partir d'une version taguée d'un applicatif dans subversion. C'est à dire une version stable, déjà testée et déployée. (Pas besoin de tests unitaires).

ok

ca doit etre possible avec Nant .Net no ?

Regarde du coté de scons, par contre je ne saurai pas te dire comment faire mais c'est possible je pense.

Bon j'ai réussi à la faire grace à Ant en utilisant les librairies svnant et ant dotnet
Je n'ai pas utilisé Nant j'en ai pas ressenti le besoin.
Je donne mon script parce que j'aurai apprécié qu'on me donne un exemple de script ça m'aurait bien aidé :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
?xml version="1.0" encoding="latin1" ?>
<!-- Sample build file used to retrieve svnant's sources -->
<project name="svn-test" basedir="." default="checkoutThis">
  
  <!--  all properties are in build.properties --> 
  <property file="build.properties" /> 

  <!-- path to the svnant libraries. Usually they will be located in ANT_HOME/lib -->
  <path id="project.classpath">
    <pathelement location="${svnjavahl.jar}" /> 
    <pathelement location="${svnant.jar}" />
    <pathelement location="${svnClientAdapter.jar}" />
  </path>  
  
   
  <!-- load the svn task -->
  <taskdef resource="svntask.properties" classpathref="project.classpath"/>
  <!-- load the svn dotnet task -->
  <taskdef resource="org/apache/ant/dotnet/antlib.xml">
    <classpath>
      <pathelement location="${antdotnet.jar}"/>
    </classpath>
  </taskdef>
  
  <!-- supprime les fichiers inutiles à la fin du script -->
  <target name="cleantemp">
    <delete dir="${temp.directory}"/>  
  </target>
  
  <!-- supprime tout !!! -->
  <target name="cleanall">
    <antcall target="cleantemp"/>
    <delete dir="${bin.result.directory}"/>
  </target>
  
  <!-- Récupère les fichiers sources, lib et scripts dans le svn -->
  <target name="svn">
    <svn username="${svn.repository.user}" password="${svn.repository.passwd}">
      <checkout url="${project.src.url}" revision="HEAD" destPath="${temp.directory}/src" />
      <checkout url="${project.scripts.url}" revision="HEAD" destPath="${temp.directory}/scripts"/>
      <checkout url="${project.lib.url}" revision="HEAD" destPath="${temp.directory}/lib"/>
    </svn>
  </target>
  
  <!-- Compile les fichiers sources à l'aide des lib et du script .csproj -->
  <target name="compile">
    <!-- Deplacement du fichier csproj dans le repertoire source afin que tout compile -->
    <move file="${temp.directory}/scripts/${project.csproj.file}" todir="${temp.directory}/src"/>
    <msbuild buildfile="${project.csproj.url}">
      <property name="Configuration" value="Release"/>
    </msbuild>
  </target>
  
  <!-- Réalise l'obfuscation -->
  <target name="obfuscation">
    <exec executable="${obfuscator}">
      <arg value="/build"/>
      <arg value="${script.obfuscator.url}"/>
    </exec>
  </target>
  
  <target name="all">
    <splash/>
    <!-- suppression du dossier bin au cas ou il existerait et nettoyage au cas ou -->
    <antcall target="cleanall"/>
    <!-- Récupération des fichiers sur le svn -->
    <antcall target="svn"/>    
    <!-- Lancement de la compilation -->
    <antcall target="compile"/>
    <!-- Lancement de l'obfuscation -->
    <antcall target="obfuscation"/>
    <!-- Deplacement du resultat de l'obfuscation ainsi que des fichiers config -->
    <move todir="${bin.result.directory}">
      <fileset dir="${temp.directory}/bin/Obfuscate"/>
    </move>
    <!-- Deplacement des fichiers de configurations -->
    <move todir="${bin.result.directory}/Config">
      <fileset dir="${temp.directory}/bin/Release/Config"/>
    </move>
    <!-- Delai d'attente avant de supprimer les fichiers inutiles. Sans cela il ne peut pas supprimer -->
    <sleep seconds="8"/>  
    <!-- Nettoyage :) -->
    <antcall target="cleantemp"/>
  </target>
  
</project>

Voila avec ça et la documentation sur Ant (facilement trouvable sur le net), on peut très vite réaliser son script de génération d'exécutable à partie d'une version tagué ou du trunk sur le svn. (mon script fait en plus de l'obfuscation)