Des scripts simples à l'application client-serveur à faire soi-même sur WCF: pourquoi j'aime travailler en CM

Automatisation une fois ou instruction de 117 pages encore et encore

Gestion de la configuration - Nouvelles aventures

Que voulaient les développeurs

• Impossible de mettre en file d'attente les correctifs. Vous devez constamment vérifier la page Web pour voir quand l'assemblage du correctif privé se termine et vous pouvez commencer à créer le vôtre.
  
• Il n'y a pas de notifications d'erreurs - pour voir les erreurs dans l'interface graphique de l'application d'assemblage, vous devez vous rendre sur le serveur et regarder beaucoup de journaux volumineux.
  
• Il n'y a pas d'historique de build pour les correctifs privés.
  

Que sont les correctifs privés

• check-in - un ensemble de changements locaux dans le code source, qui est apporté au code stocké dans TFS. Cette vérification peut être vérifiée à l'aide de processus d'intégration continue / d'archivage fermé qui vous permettent d'ignorer uniquement le code correct et de rejeter toutes les vérifications qui violent la collecte du projet final.
  
• shelveset - un ensemble de changements locaux dans le code source qui n'est pas directement apporté au code source situé dans TFS, mais qui est accessible par son nom. Le shellset peut être déployé sur la machine locale du développeur ou du système de build pour fonctionner avec du code modifié qui n'est pas inclus dans TFS. En outre, le shellset peut être ajouté à TFS comme vérification après le déploiement, lorsque tout le travail est terminé. Par exemple, le contrôleur de porte fonctionne de cette façon. Tout d'abord, le shellset sur le générateur est vérifié. Si la vérification réussit, le shellset se transforme en vérification!
  

1. Obtient le nom (numéro) du shellset et le déploie sur le générateur de correctifs privé. En conséquence, nous obtenons le code source de la version du produit ainsi que les modifications / correctifs du shellset. La branche de publication reste inchangée.
   
2. Sur un générateur de correctifs privés, un projet ou une série de projets va pour lesquels un correctif privé a été effectué.
   
3. L'ensemble des fichiers binaires compilés est copié dans le répertoire réseau du correctif privé. Le catalogue contient le nom du shellset, qui est une séquence de nombres.
   
4. Le code source du générateur de correctifs privés est restauré dans sa forme d'origine.
   

Quel était le mien

• Un générateur de correctifs privés qui a collecté des correctifs privés à partir du shellset TFS en lançant une application console avec les paramètres de ligne de commande donnés.
  
• Veeam.Builder.Agent - un service WCF écrit par Veeam qui lance l'application avec des paramètres en mode console sous l'utilisateur actuel et renvoie l'état actuel de l'application.
  
• Le service Web IIS est une application sur Windows Forms qui vous permet de saisir le nom du shellset, les paramètres spécifiés et de démarrer le processus de création d'un correctif privé.
  
• Une connaissance très peu approfondie de la programmation est le C ++, un peu de C # à l'université, et l'écriture de petites applications pour l'automatisation, ajoutant de nouvelles fonctions aux processus de construction actuels et comme passe-temps.
  
• Des collègues expérimentés, Google et des articles indiens MSDN sont des sources de réponses à toutes les questions.
  

Que ferons-nous

• QBuilder.AppQueue est mon service WCF qui fournit le travail avec la file d'attente de génération et appelle le service Veeam.Builder.Agent pour exécuter le programme de génération.
  
• dummybuild.exe est un programme de remplacement utilisé pour le débogage et comme aide visuelle. Nécessaire pour visualiser les paramètres transférés.
  
• QBuilder.AppLauncher - Service WCF qui exécute des applications dans la console de l'utilisateur actuel et fonctionne en mode interactif. Il s'agit d'un analogue considérablement simplifié du programme Veeam.Builder.Agent écrit spécifiquement pour cet article. Le service d'origine peut fonctionner comme un service Windows et exécuter des applications dans la console, ce qui nécessite un travail supplémentaire avec l'API Windows. Pour décrire toutes les astuces, un article séparé serait nécessaire. Mon exemple fonctionne comme un simple service de console interactive et utilise deux fonctions - démarrer un processus avec des paramètres et vérifier son état.
  

Création de services WCF

Créez le service QBuilder.AppLauncher

1. Créez une nouvelle application console appelée QBuilder.AppLauncher
   
2. Renommez Program.cs en Service.cs
   
3. Renommez l'espace de noms en QBuilder.AppLauncher
   
4. Ajoutez les références suivantes au projet:
   a. System.ServiceModel.dll
   b. System.ServiceProcess.dll
   c. System.Configuration.Install.dll
   
5. Ajoutez les définitions suivantes à Service.cs
   
   

   using System.ComponentModel; using System.ServiceModel; using System.ServiceProcess; using System.Configuration; using System.Configuration.Install; 

   
   Au cours de l'assemblage ultérieur, les définitions suivantes seront également nécessaires:
   
   

    using System.Reflection; using System.Xml.Linq; using System.Xml.XPath; 

6. Nous définissons l'interface IAppLauncher et ajoutons des fonctions pour travailler avec la file d'attente:
   
   

    //    [ServiceContract(Namespace = "http://QBuilder.AppLauncher")]   public interface IAppLauncher   {    //             [OperationContract]       bool TestConnection();   } 

7. Dans la classe AppLauncherService, nous implémentons l'interface et la fonction de test TestConnection:
   
   

    public class AppLauncherService : IAppLauncher   {       public bool TestConnection()       {           return true;       }   } 

8. Créez une nouvelle classe AppLauncherWindowsService qui hérite de la classe ServiceBase. Ajoutez la variable locale serviceHost - un lien vers ServiceHost. Nous définissons la méthode Main, qui appelle ServiceBase.Run (nouveau AppLauncherWindowsService ()):
   
   

    public class AppLauncherWindowsService : ServiceBase   {       public ServiceHost serviceHost = null;       public AppLauncherWindowsService()       {           // Name the Windows Service           ServiceName = "QBuilder App Launcher";       }       public static void Main()       {           ServiceBase.Run(new AppLauncherWindowsService());       } 

9. Remplacez la fonction OnStart () qui crée la nouvelle instance ServiceHost:
   
   

    protected override void OnStart(string[] args)       {           if (serviceHost != null)           {               serviceHost.Close();           }           // Create a ServiceHost for the CalculatorService type and           // provide the base address.           serviceHost = new ServiceHost(typeof(AppLauncherService));           // Open the ServiceHostBase to create listeners and start           // listening for messages.           serviceHost.Open();       } 

10. Remplacez la fonction onStop qui ferme l'instance ServiceHost:
    
    

     protected override void OnStop()       {           if (serviceHost != null)           {               serviceHost.Close();               serviceHost = null;           }       }   } 

11. Créez une nouvelle classe ProjectInstaller, héritée d'Installer et marquée avec RunInstallerAttribute, qui est définie sur True. Cela vous permet d'installer le service Windows à l'aide du programme installutil.exe:
    
    

     [RunInstaller(true)]   public class ProjectInstaller : Installer   {       private ServiceProcessInstaller process;       private ServiceInstaller service;       public ProjectInstaller()       {           process = new ServiceProcessInstaller();           process.Account = ServiceAccount.LocalSystem;           service = new ServiceInstaller();           service.ServiceName = "QBuilder App Launcher";           Installers.Add(process);           Installers.Add(service);       }   } 

12. Modifiez le contenu du fichier app.config:
    
    

     <?xml version="1.0" encoding="utf-8" ?> <configuration> <system.serviceModel>   <services>     <service name="QBuilder.AppLauncher.AppLauncherService"              behaviorConfiguration="AppLauncherServiceBehavior">       <host>         <baseAddresses>           <add baseAddress="http://localhost:8000/QBuilderAppLauncher/service"/>         </baseAddresses>       </host>       <endpoint address=""                 binding="wsHttpBinding"                 contract="QBuilder.AppLauncher.IAppLauncher" />       <endpoint address="mex"                 binding="mexHttpBinding"                 contract="IMetadataExchange" />     </service>   </services>   <behaviors>     <serviceBehaviors>       <behavior name="AppLauncherServiceBehavior">         <serviceMetadata httpGetEnabled="true"/>         <serviceDebug includeExceptionDetailInFaults="False"/>       </behavior>     </serviceBehaviors>   </behaviors> </system.serviceModel> </configuration> 

Vérification du bon fonctionnement du service

1. Nous compilons le service.
   
2. Installez-le avec la commande installutil.exe
   1) Accédez au dossier où se trouve le fichier de service compilé
   2) Exécutez la commande d'installation:
   C: \ Windows \ Microsoft.NET \ Framework64 \ v4.0.30319 \ InstallUtil.exe
3. Nous allons dans le composant logiciel enfichable services.msc, vérifions la disponibilité du service QBuilder App Launcher et l'exécutons.
   
4. Nous vérifions l'aptitude au service du service à l'aide du programme WcfTestClient.exe, qui est inclus avec VisualStudio:
   
   1) Exécutez WcfTestClient
   2) Ajoutez l'adresse du service: http: // localhost: 8000 / QBuilderAppLauncher / service
   3) L'interface de service s'ouvre:
   
   
   
   4) Nous appelons la fonction de test TestConnection, vérifions que tout fonctionne et que la fonction renvoie une valeur:
   
   

Pourquoi ai-je besoin d'une fonction de test qui ne fait rien

Ajoutez la possibilité d'exécuter à partir de la console

1. Ajoutez la procédure RunInteractive à la classe AppLauncherWindowsService, qui fournit le service en mode console:
   
   

    static void RunInteractive(ServiceBase[] services) {   Console.WriteLine("Service is running in interactive mode.");   Console.WriteLine();   var start = typeof(ServiceBase).GetMethod("OnStart", BindingFlags.Instance | BindingFlags.NonPublic);   foreach (var service in services)   {       Console.Write("Starting {0}...", service.ServiceName);       start.Invoke(service, new object[] { new string[] { } });       Console.Write("Started {0}", service.ServiceName);   }   Console.WriteLine();   Console.WriteLine("Press any key to stop the services and end the process...");   Console.ReadKey();   Console.WriteLine();   var stop = typeof(ServiceBase).GetMethod("OnStop", BindingFlags.Instance | BindingFlags.NonPublic);   foreach (var service in services)   {       Console.Write("Stopping {0}...", service.ServiceName);       stop.Invoke(service, null);       Console.WriteLine("Stopped {0}", service.ServiceName);   }   Console.WriteLine("All services stopped."); } 

2. Nous apportons des modifications à la procédure principale - ajout du traitement des paramètres de ligne de commande. Avec l'option / console et une session utilisateur active ouverte, nous lançons le programme en mode interactif. Sinon, nous le lançons en tant que service.
   
   

    public static void Main(string[] args) {   var services = new ServiceBase[]   {       new AppLauncherWindowsService()   };   //           ,      /console   if (args.Length == 1 && args[0] == "/console" && Environment.UserInteractive)   {       //            RunInteractive(services);   }   else   {       //          ServiceBase.Run(services);   } } 

Ajouter des fonctions pour lancer l'application et vérifier son statut

1. Tout d'abord, ajoutez la variable globale appProcess, qui stocke le processus en cours d'exécution.
   
   Ajoutez-le à la public class AppLauncherService : IAppLauncher :
   
   

    public class AppLauncherService : IAppLauncher   {       Process appProcess; 

2. Ajoutez une fonction à la même classe qui vérifie l'état du processus en cours d'exécution:
   
   

       public bool IsStarted()       {           if (appProcess!=null)           {               if (appProcess.HasExited)               {                   return false;               }               else               {                   return true;               }           }           else           {               return false;           }       } 

   
   La fonction renvoie false si le processus n'existe pas ou n'est pas déjà en cours d'exécution et true si le processus est actif.
   
3. Ajoutez la fonction pour lancer l'application:
   
   

    public bool Start(string fileName, string arguments, string workingDirectory, string domain, string userName, int timeoutInMinutes)       {           ProcessStartInfo processStartInfo = new ProcessStartInfo();           processStartInfo.FileName = fileName;           processStartInfo.Arguments = arguments;           processStartInfo.Domain = domain;           processStartInfo.UserName = userName;           processStartInfo.CreateNoWindow = false;           processStartInfo.UseShellExecute = false;           try           {               if (appProcess!=null)               {                   if (!appProcess.HasExited)                   {                       Console.WriteLine("Process is still running. Waiting...");                       return false;                   }               }           }           catch (Exception ex)           {               Console.WriteLine("Error while checking process: {0}", ex);           }           try           {               appProcess = new Process();               appProcess.StartInfo = processStartInfo;               appProcess.Start();           }           catch (Exception ex)           {               Console.WriteLine("Error while starting process: {0}",ex);           }           return true;                          } 

Lancement du service QBuilder.AppLauncher

1. Pour fonctionner, vous avez besoin des fichiers QBuilder.AppLauncher.exe et QBuilder.AppLauncher.exe.config, qui sont dans l'archive sur le lien ci-dessus. Le code source de cette application d'auto-assemblage s'y trouve également.
   
2. Nous démarrons le service avec des droits d'administrateur.
   
3. La fenêtre de console du service s'ouvrira:
   

1. Pour les tests, exécutez wcftestclient.exe, fourni avec Visual Studio. Nous vérifions la disponibilité du service sur http: // localhost: 8000 / QBuilderAppLauncher / service ou ouvrons le lien dans Internet Explorer.
   

Création du service QBuilder.AppQueue

Ajouter un lien vers le service QBuilder.AppLauncher à utiliser dans le service de file d'attente

1. Dans l'Explorateur de solutions pour notre projet, sélectionnez Ajouter une référence de service et spécifiez l'adresse: localhost : 8000 / QBuilderAppLauncher / service
   
2. Sélectionnez l'espace de noms: AppLauncherService.
   

Créer une structure pour stocker des éléments de file d'attente

 // ,     public class QBuildRecord { // ID  public string BuildId { get; set; } // ID  public string IssueId { get; set; } //   public string IssueName { get; set; } //    public DateTime StartDate { get; set; } //    public DateTime FinishDate { get; set; } //    C# public bool Build_CSharp { get; set; } //    C++ public bool Build_Cpp { get; set; } } 

Implémentation de la classe de file d'attente CXmlQueue

• Constructeur CXmlQueue - définit le nom initial du fichier dans lequel la file d'attente est stockée.
  
• SetCurrentBuild - écrit des informations sur la construction actuelle dans le fichier XML de file d'attente. Il s'agit d'un élément qui n'est pas dans la file d'attente; il stocke des informations sur le processus en cours d'exécution. Peut être vide.
  
• GetCurrentBuild - Obtient les paramètres du processus en cours d'exécution à partir du fichier XML de file d'attente. Peut être vide.
  
• ClearCurrentBuild - Cela efface l'élément currentbuild dans le fichier XML de file d'attente si le processus se termine.
  
• OpenXmlQueue - fonction pour ouvrir le fichier XML où la file d'attente est stockée. Si le fichier est manquant, un nouveau est créé.
  
• GetLastQueueBuildNumber - chaque build de la file d'attente a son propre numéro de série unique. Cette fonction renvoie sa valeur, qui est stockée dans l'attribut racine.
  
• IncrementLastQueueBuildNumber - augmente la valeur du numéro de build lors de la mise en file d'attente d'une nouvelle build.
  
• GetCurrentQueue - Renvoie une liste d'éléments QBuildRecord à partir du fichier XML de file d'attente.
  

 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Xml.Linq; using System.Xml.XPath; using System.IO; namespace QBuilder.AppQueue { . . . } 

 //      XML  public class CXmlQueue { //  ,    string xmlBuildQueueFile; public CXmlQueue(string _xmlQueueFile) { xmlBuildQueueFile = _xmlQueueFile; } public string GetQueueFileName() { return xmlBuildQueueFile; } // ,       xml (   xml) public QBuildRecord GetCurrentBuild() { QBuildRecord qBr; XElement xRoot = OpenXmlQueue(); XElement xCurrentBuild = xRoot.XPathSelectElement("currentbuild"); if (xCurrentBuild != null) { qBr = new QBuildRecord(); qBr.BuildId = xCurrentBuild.Attribute("BuildId").Value; qBr.IssueId = xCurrentBuild.Attribute("IssueId").Value; qBr.StartDate = Convert.ToDateTime(xCurrentBuild.Attribute("StartDate").Value); return qBr; } return null; } // ,       xml (   xml) public void SetCurrentBuild(QBuildRecord qbr) { XElement xRoot = OpenXmlQueue(); XElement newXe = (new XElement( "currentbuild", new XAttribute("BuildId", qbr.BuildId), new XAttribute("IssueId", qbr.IssueId), new XAttribute("StartDate", DateTime.Now.ToString()) )); XElement xCurrentBuild = xRoot.XPathSelectElement("currentbuild"); if (xCurrentBuild != null) { xCurrentBuild.Remove(); // remove old value } xRoot.Add(newXe); xRoot.Save(xmlBuildQueueFile); } // ,       xml,  ,    public void ClearCurrentBuild() { XElement xRoot = OpenXmlQueue(); try { XElement xCurrentBuild = xRoot.XPathSelectElement("currentbuild"); if (xCurrentBuild != null) { Console.WriteLine("Clearing current build information."); xCurrentBuild.Remove(); } } catch (Exception ex) { Console.WriteLine("XML queue doesn't have running build yet. Nothing to clear!"); } xRoot.Save(xmlBuildQueueFile); } //   XML           public XElement OpenXmlQueue() { XElement xRoot; if (File.Exists(xmlBuildQueueFile)) { xRoot = XElement.Load(xmlBuildQueueFile, LoadOptions.None); } else { Console.WriteLine("Queue file {0} not found. Creating...", xmlBuildQueueFile); XElement xE = new XElement("BuildsQueue", new XAttribute("BuildNumber", 0)); xE.Save(xmlBuildQueueFile); xRoot = XElement.Load(xmlBuildQueueFile, LoadOptions.None); } return xRoot; } //       public int GetLastQueueBuildNumber() { XElement xRoot = OpenXmlQueue(); if (xRoot.HasAttributes) return int.Parse(xRoot.Attribute("BuildNumber").Value); return 0; } //              public int IncrementLastQueueBuildNumber() { int buildIndex = GetLastQueueBuildNumber(); buildIndex++; XElement xRoot = OpenXmlQueue(); xRoot.Attribute("BuildNumber").Value = buildIndex.ToString(); xRoot.Save(xmlBuildQueueFile); return buildIndex; } //    xml     QBuildRecord public List<QBuildRecord> GetCurrentQueue() { List<QBuildRecord> qList = new List<QBuildRecord>(); XElement xRoot = OpenXmlQueue(); if (xRoot.XPathSelectElements("build").Any()) { List<XElement> xBuilds = xRoot.XPathSelectElements("build").ToList(); foreach (XElement xe in xBuilds) { qList.Add(new QBuildRecord { BuildId = xe.Attribute("BuildId").Value, IssueId = xe.Attribute("IssueId").Value, IssueName = xe.Attribute("IssueName").Value, StartDate = Convert.ToDateTime(xe.Attribute("StartDate").Value), Build_CSharp = bool.Parse(xe.Attribute("Build_CSharp").Value), Build_Cpp = bool.Parse(xe.Attribute("Build_Cpp").Value) }); } } return qList; } } 

 <?xml version="1.0" encoding="utf-8"?> <BuildsQueue BuildNumber="23"> <build BuildId="14" IssueId="26086" IssueName="TestIssueName" StartDate="2018-06-13T16:49:50.515238+02:00" Build_CSharp="true" Build_Cpp="true" /> <build BuildId="15" IssueId="59559" IssueName="TestIssueName" StartDate="2018-06-13T16:49:50.6880927+02:00" Build_CSharp="true" Build_Cpp="true" /> <build BuildId="16" IssueId="45275" IssueName="TestIssueName" StartDate="2018-06-13T16:49:50.859937+02:00" Build_CSharp="true" Build_Cpp="true" /> <build BuildId="17" IssueId="30990" IssueName="TestIssueName" StartDate="2018-06-13T16:49:51.0321322+02:00" Build_CSharp="true" Build_Cpp="true" /> <build BuildId="18" IssueId="16706" IssueName="TestIssueName" StartDate="2018-06-13T16:49:51.2009904+02:00" Build_CSharp="true" Build_Cpp="true" /> <build BuildId="19" IssueId="66540" IssueName="TestIssueName" StartDate="2018-06-13T16:49:51.3581274+02:00" Build_CSharp="true" Build_Cpp="true" /> <build BuildId="20" IssueId="68618" IssueName="TestIssueName" StartDate="2018-06-13T16:49:51.5087854+02:00" Build_CSharp="true" Build_Cpp="true" /> <build BuildId="21" IssueId="18453" IssueName="TestIssueName" StartDate="2018-06-13T16:49:51.6713477+02:00" Build_CSharp="true" Build_Cpp="true" /> <build BuildId="22" IssueId="68288" IssueName="TestIssueName" StartDate="2018-06-13T16:49:51.8277942+02:00" Build_CSharp="true" Build_Cpp="true" /> <build BuildId="23" IssueId="89884" IssueName="TestIssueName" StartDate="2018-06-13T16:49:52.0151294+02:00" Build_CSharp="true" Build_Cpp="true" /> <currentbuild BuildId="13" IssueId="4491" StartDate="13.06.2018 16:53:16" /> </BuildsQueue> 

Ajouter une classe AuxFunctions

 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace QBuilder.AppQueue { class AuxFunctions { //       public static string FormatParameters(string fileName, IDictionary<string, string> parameters) { if (String.IsNullOrWhiteSpace(fileName)) { throw new ArgumentNullException("fileName"); } if (parameters == null) { throw new ArgumentNullException("parameters"); } var macros = String.Join(" ", parameters.Select(parameter => String.Format("\"{0}={1}\"", parameter.Key, parameter.Value.Replace(@"""", @"\""")))); return String.Format("{0} /b \"{1}\"", macros, fileName); } } } 

Ajouter de nouvelles fonctionnalités à l'interface de service

• PushBuild (QBuildRecord): vide. Il s'agit d'une fonction qui ajoute une nouvelle valeur au fichier XML de file d'attente avec les paramètres QBuildRecord
  
• TestPushBuild (): vide. Il s'agit d'une fonction de test qui ajoute des données de test à une file d'attente dans un fichier XML.
  
• PullBuild: QBuildRecord. Il s'agit d'une fonction qui reçoit la valeur QBuildRecord du fichier XML de file d'attente. Il peut être vide.
  

  public interface IAppQueue { //     [OperationContract] void PushBuild(QBuildRecord qBRecord); //     [OperationContract] void TestPushBuild(); //      [OperationContract] QBuildRecord PullBuild(); } 

Nous implémentons des fonctions dans la classe AppQueueService: IAppQueue:

 public class AppQueueService : IAppQueue { //  ,    public AppLauncherClient buildAgent; // ,      private string _xmlQueueFile; public AppQueueService() { //       .     ,  . _xmlQueueFile = ConfigurationManager.AppSettings["QueueFileName"]; } public QBuildRecord PullBuild() { QBuildRecord qBr; CXmlQueue xmlQueue = new CXmlQueue(_xmlQueueFile); XElement xRoot = xmlQueue.OpenXmlQueue(); if (xRoot.XPathSelectElements("build").Any()) { qBr = new QBuildRecord(); XElement xe = xRoot.XPathSelectElements("build").FirstOrDefault(); qBr.BuildId = xe.Attribute("BuildId").Value; qBr.IssueId = xe.Attribute("IssueId").Value; qBr.IssueName = xe.Attribute("IssueName").Value; qBr.StartDate = Convert.ToDateTime(xe.Attribute("StartDate").Value); qBr.Build_CSharp = bool.Parse(xe.Attribute("Build_CSharp").Value); qBr.Build_Cpp = bool.Parse(xe.Attribute("Build_Cpp").Value); xe.Remove(); // Remove first element xRoot.Save(xmlQueue.GetQueueFileName()); return qBr; } return null; } public void PushBuild(QBuildRecord qBRecord) { CXmlQueue xmlQueue = new CXmlQueue(_xmlQueueFile); XElement xRoot = xmlQueue.OpenXmlQueue(); xRoot.Add(new XElement( "build", new XAttribute("BuildId", qBRecord.BuildId), new XAttribute("IssueId", qBRecord.IssueId), new XAttribute("IssueName", qBRecord.IssueName), new XAttribute("StartDate", qBRecord.StartDate), new XAttribute("Build_CSharp", qBRecord.Build_CSharp), new XAttribute("Build_Cpp", qBRecord.Build_Cpp) )); xRoot.Save(xmlQueue.GetQueueFileName()); } public void TestPushBuild() { CXmlQueue xmlQueue = new CXmlQueue(_xmlQueueFile); Console.WriteLine("Using queue file: {0}",xmlQueue.GetQueueFileName()); int buildIndex = xmlQueue.IncrementLastQueueBuildNumber(); Random rnd = new Random(); PushBuild (new QBuildRecord { Build_CSharp = true, Build_Cpp = true, BuildId = buildIndex.ToString(), StartDate = DateTime.Now, IssueId = rnd.Next(100000).ToString(), IssueName = "TestIssueName" } ); } } 

Apporter des modifications à la classe AppQueueWindowsService: ServiceBase

 // ,         private System.Timers.Timer timer; // ,       public QBuildRecord currentBuild; //public QBuildRecord processingBuild; // ,       public bool clientStarted; //    public string xmlBuildQueueFileName; //   public CXmlQueue xmlQueue; //         public string btWorkingDir; public string btLocalDomain; public string btUserName; public string buildToolPath; public string btScriptPath; public int agentTimeoutInMinutes; //  public AppQueueService buildQueueService; 

 //          try { xmlBuildQueueFileName = ConfigurationManager.AppSettings["QueueFileName"]; buildToolPath = ConfigurationManager.AppSettings["BuildToolPath"]; btWorkingDir = ConfigurationManager.AppSettings["BuildToolWorkDir"]; btLocalDomain = ConfigurationManager.AppSettings["LocalDomain"]; btUserName = ConfigurationManager.AppSettings["UserName"]; btScriptPath = ConfigurationManager.AppSettings["ScriptPath"]; agentTimeout= 30000; //    buildQueueService = new AppQueueService(); //    xmlQueue = new CXmlQueue(xmlBuildQueueFileName); } catch (Exception ex) { Console.WriteLine("Error while loading configuration: {0}", ex); } 

 //        public bool BuildIsStarted() { IAppLauncher builderAgent; try { builderAgent = new AppLauncherClient(); return builderAgent.IsStarted(); } catch (Exception ex) { return false; } } 

  private void TimerTick(object sender, System.Timers.ElapsedEventArgs e) { try { //     if (!BuildIsStarted()) { //     clientStarted,     if (clientStarted) { //     ,  clientStarted  false      currentBuild.FinishDate = DateTime.Now; clientStarted = false; } else { //       clientStarted=false ( ) -      xmlQueue.ClearCurrentBuild(); } //        currentBuild = buildQueueService.PullBuild(); //    ,     if (currentBuild != null) { //     true -    clientStarted = true; //   currentbuild -     xml            xmlQueue.SetCurrentBuild(currentBuild); //      var parameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) { {"BUILD_ID", currentBuild.BuildId}, {"ISSUE_ID", currentBuild.IssueId}, {"ISSUE_NAME", currentBuild.IssueName}, {"BUILD_CSHARP", currentBuild.Build_CSharp ? "1" : "0"}, {"BUILD_CPP", currentBuild.Build_Cpp ? "1" : "0"} }; //       var arguments = AuxFunctions.FormatParameters(btScriptPath, parameters); try { //          AppLauncher IAppLauncher builderAgent = new AppLauncherClient(); builderAgent.Start(buildToolPath, arguments, btWorkingDir, btLocalDomain, btUserName, agentTimeout); } catch (Exception ex) { Console.WriteLine(ex); } } } } catch (Exception ex) { Console.WriteLine(ex); } } 

 //     OnStart protected override void OnStart(string[] args) { if (serviceHost != null) { serviceHost.Close(); } //      this.timer = new System.Timers.Timer(agentTimeout); //    this.timer.AutoReset = true; this.timer.Elapsed += new System.Timers.ElapsedEventHandler(this.TimerTick); this.timer.Start(); //  ServiceHost   AppQueueService serviceHost = new ServiceHost(typeof(AppQueueService)); //  ServiceHostBase      serviceHost.Open(); } 

 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.ComponentModel; using System.ServiceModel; using System.ServiceProcess; using System.Configuration; using System.Configuration.Install; using System.Reflection; using System.Xml.Linq; using System.Xml.XPath; using QBuilder.AppQueue.AppLauncherService; 

App.config

 <appSettings> <add key="QueueFileName" value="BuildQueue.xml"/> <add key="BuildToolPath" value="c:\temp\dummybuild.exe"/> <add key="BuildToolWorkDir" value="c:\temp\"/> <add key="LocalDomain" value="."/> <add key="UserName" value="username"/> <add key="ScriptPath" value="C:\Temp\BuildSample.bld"/> </appSettings> 

1. QBuilder.AppLauncher.zip. .
   
2. dummybuild.exe binaries , , c:\temp. , . , BuildToolPath BuildToolWorkDir .
   
3. \QBuilder.AppLauncher\binaries\QBuilder.AppLauncher\ QBuilder.AppLauncher.exe . .
   
4. QBuilder.AppQueue.exe /console .
   
5. , :
   
   
   
6. . , 30 :
   
   
   
7. BuildQueue.xml , currentbuild:
   
   

    <?xml version="1.0" encoding="utf-8"?> <BuildsQueue BuildNumber="23"> <build BuildId="19" IssueId="66540" IssueName="TestIssueName" StartDate="2018-06-13T16:49:51.3581274+02:00" Build_CSharp="true" Build_Cpp="true" /> <build BuildId="20" IssueId="68618" IssueName="TestIssueName" StartDate="2018-06-13T16:49:51.5087854+02:00" Build_CSharp="true" Build_Cpp="true" /> <build BuildId="21" IssueId="18453" IssueName="TestIssueName" StartDate="2018-06-13T16:49:51.6713477+02:00" Build_CSharp="true" Build_Cpp="true" /> <build BuildId="22" IssueId="68288" IssueName="TestIssueName" StartDate="2018-06-13T16:49:51.8277942+02:00" Build_CSharp="true" Build_Cpp="true" /> <build BuildId="23" IssueId="89884" IssueName="TestIssueName" StartDate="2018-06-13T16:49:52.0151294+02:00" Build_CSharp="true" Build_Cpp="true" /> <currentbuild BuildId="18" IssueId="16706" StartDate="13.06.2018 23:20:06" /> </BuildsQueue> 

   
   
8. dummy , :
   
   

    <?xml version="1.0" encoding="utf-8"?> <BuildsQueue BuildNumber="23"> <build BuildId="21" IssueId="18453" IssueName="TestIssueName" StartDate="2018-06-13T16:49:51.6713477+02:00" Build_CSharp="true" Build_Cpp="true" /> <build BuildId="22" IssueId="68288" IssueName="TestIssueName" StartDate="2018-06-13T16:49:51.8277942+02:00" Build_CSharp="true" Build_Cpp="true" /> <build BuildId="23" IssueId="89884" IssueName="TestIssueName" StartDate="2018-06-13T16:49:52.0151294+02:00" Build_CSharp="true" Build_Cpp="true" /> <currentbuild BuildId="20" IssueId="68618" StartDate="13.06.2018 23:24:25" /> </BuildsQueue>