Desde simples scripts hasta aplicaciones cliente-servidor de bricolaje en WCF: por qué me gusta trabajar en CM

Automatización una vez o instrucción de 117 páginas una y otra vez

Gestión de configuración - Nuevas aventuras

¿Qué querían los desarrolladores?

• No se pueden poner en cola las correcciones. Debe verificar constantemente la página web para ver cuándo finaliza el ensamblaje del arreglo privado y puede comenzar a construir el suyo.
  
• No hay notificaciones sobre errores: para ver los errores en la GUI de la aplicación de ensamblaje, debe ir al servidor y observar muchos registros voluminosos.
  
• No hay historial de compilación para arreglos privados.
  

¿Qué son arreglos privados?

• check-in: un conjunto de cambios locales en el código fuente, que se realiza en el código almacenado en TFS. Esta verificación puede verificarse mediante los procesos de Integración continua / Verificación cerrada que le permiten omitir solo el código correcto y rechazar todas las verificaciones que violen la recopilación del proyecto final.
  
• shelveset: un conjunto de cambios locales en el código fuente que no se realiza directamente en el código fuente ubicado en TFS, pero que es accesible por su nombre. El shellset se puede implementar en la máquina local del desarrollador o sistema de compilación para trabajar con código modificado que no está incluido en TFS. Además, el shellset se puede agregar a TFS como una comprobación después de la implementación, cuando se completa todo el trabajo con él. Por ejemplo, el verificador de puerta funciona de esta manera. Primero, se marca el shellset en el constructor. Si la verificación es exitosa, el shellset se convierte en una verificación
  

1. Obtiene el nombre (número) del conjunto de shell y lo implementa en el generador de arreglos privados. Como resultado, obtenemos el código fuente del producto de lanzamiento más los cambios / arreglos del shellset. La rama de liberación permanece sin cambios.
   
2. En un generador de arreglos privados, se va a ejecutar un proyecto o una serie de proyectos para los que se ha realizado un arreglo privado.
   
3. El conjunto de archivos binarios compilados se copia en el directorio de red del arreglo privado. El catálogo contiene el nombre del shellset, que es una secuencia de números.
   
4. El código fuente en el generador de arreglos privados se restaura a su forma original.
   

Lo que era mio

• Un generador de arreglos privados que recopiló arreglos privados del conjunto de shell TFS al iniciar una aplicación de consola con los parámetros de línea de comandos dados.
  
• Veeam.Builder.Agent: un servicio WCF escrito por Veeam que inicia la aplicación con parámetros en modo consola bajo el usuario actual y devuelve el estado actual de la aplicación.
  
• El servicio web IIS es una aplicación en formularios Windows Forms que le permite ingresar el nombre del shellset, los parámetros especificados y comenzar el proceso de creación de una solución privada.
  
• Un conocimiento de programación muy superficial es C ++, un poco de C # en la universidad, y escribe pequeñas aplicaciones para la automatización, agregando nuevas funciones a los procesos de construcción actuales y como un pasatiempo.
  
• Los colegas con experiencia, Google y los artículos indios de MSDN son fuentes de respuestas a todas las preguntas.
  

Que haremos

• QBuilder.AppQueue es mi servicio WCF que proporciona trabajo con la cola de compilación y llama al servicio Veeam.Builder.Agent para ejecutar el programa de compilación.
  
• dummybuild.exe es un programa de código auxiliar utilizado para la depuración y como una ayuda visual. Necesario para visualizar los parámetros transferidos.
  
• QBuilder.AppLauncher: servicio WCF que ejecuta aplicaciones en la consola del usuario actual y funciona en modo interactivo. Este es un análogo significativamente simplificado del programa Veeam.Builder.Agent escrito específicamente para este artículo. El servicio original puede funcionar como un servicio de Windows y ejecutar aplicaciones en la consola, lo que requiere un trabajo adicional con la API de Windows. Para describir todos los trucos, se requeriría un artículo separado. Mi ejemplo funciona como un simple servicio de consola interactiva y usa dos funciones: iniciar un proceso con parámetros y verificar su estado.
  

Crear servicios WCF

Cree el servicio QBuilder.AppLauncher

1. Cree una nueva aplicación de consola llamada QBuilder.AppLauncher
   
2. Cambiar el nombre de Program.cs a Service.cs
   
3. Cambiar el nombre del espacio de nombres a QBuilder.AppLauncher
   
4. Agregue las siguientes referencias al proyecto:
   a. System.ServiceModel.dll
   b. System.ServiceProcess.dll
   c. System.Configuration.Install.dll
   
5. Agregue las siguientes definiciones a Service.cs
   
   

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

   
   Durante el montaje posterior, también se necesitarán las siguientes definiciones:
   
   

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

6. Definimos la interfaz IAppLauncher y agregamos funciones para trabajar con la cola:
   
   

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

7. En la clase AppLauncherService, implementamos la interfaz y la función de prueba TestConnection:
   
   

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

8. Cree una nueva clase AppLauncherWindowsService que herede la clase ServiceBase. Agregue la variable local serviceHost, un enlace a ServiceHost. Definimos el método Main, que llama a ServiceBase.Run (nuevo 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. Anule la función OnStart () que crea la nueva instancia de 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. Anule la función onStop que cierra la instancia de ServiceHost:
    
    

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

11. Cree una nueva clase ProjectInstaller, heredada del instalador y marcada con RunInstallerAttribute, que se establece en True. Esto le permite instalar el servicio de Windows utilizando el programa 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. Cambie el contenido del archivo 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> 

Comprobación de la capacidad de servicio del servicio.

1. Recopilamos el servicio.
   
2. Instálelo con el comando installutil.exe
   1) Vaya a la carpeta donde se encuentra el archivo de servicio compilado
   2) Ejecute el comando de instalación:
   C: \ Windows \ Microsoft.NET \ Framework64 \ v4.0.30319 \ InstallUtil.exe
3. Entramos en el complemento services.msc, verificamos la disponibilidad del servicio QBuilder App Launcher y lo ejecutamos.
   
4. Verificamos la capacidad de servicio del servicio utilizando el programa WcfTestClient.exe, que se incluye con VisualStudio:
   
   1) Ejecute WcfTestClient
   2) Agregue la dirección del servicio: http: // localhost: 8000 / QBuilderAppLauncher / service
   3) Se abre la interfaz de servicio:
   
   
   
   4) Llamamos a la función de prueba TestConnection, verificamos que todo funcione y la función devuelve un valor:
   
   

¿Por qué necesito una función de prueba que no hace nada?

Agregue la capacidad de ejecutar desde la consola

1. Agregue el procedimiento RunInteractive a la clase AppLauncherWindowsService, que proporciona el servicio en modo consola:
   
   

    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. Realizamos cambios en el procedimiento Principal: agregue el procesamiento de los parámetros de la línea de comandos. Con la opción / console y una sesión de usuario activa abierta, lanzamos el programa en modo interactivo. De lo contrario, lo lanzamos como un servicio.
   
   

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

Agregue funciones para iniciar la aplicación y verificar su estado

1. Primero, agregue la variable global appProcess, que almacena el proceso actualmente en ejecución.
   
   public class AppLauncherService : IAppLauncher a la public class AppLauncherService : IAppLauncher :
   
   

    public class AppLauncherService : IAppLauncher   {       Process appProcess; 

2. Agregue una función a la misma clase que verifica el estado del proceso en ejecución:
   
   

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

   
   La función devuelve falso si el proceso no existe o no se está ejecutando, y verdadero si el proceso está activo.
   
3. Agregue la función para iniciar la aplicación:
   
   

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

Lanzamiento del servicio QBuilder.AppLauncher

1. Para trabajar, necesita los archivos QBuilder.AppLauncher.exe y QBuilder.AppLauncher.exe.config, que se encuentran en el archivo en el enlace de arriba. El código fuente de esta aplicación para el autoensamblaje también se encuentra allí.
   
2. Iniciamos el servicio con derechos de administrador.
   
3. Se abrirá la ventana de la consola del servicio:
   

1. Para las pruebas, ejecute wcftestclient.exe, que se incluye con Visual Studio. Verificamos la disponibilidad del servicio en http: // localhost: 8000 / QBuilderAppLauncher / service o abrimos el enlace en Internet Explorer.
   

Crear el servicio QBuilder.AppQueue

Agregue un enlace al servicio QBuilder.AppLauncher para usar en el servicio de cola

1. En el Explorador de soluciones para nuestro proyecto, seleccione Agregar referencia de servicio y especifique la dirección: localhost : 8000 / QBuilderAppLauncher / service
   
2. Seleccione el espacio de nombres: AppLauncherService.
   

Crear una estructura para almacenar elementos de cola

 // ,     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; } } 

Implementación de la clase de cola CXmlQueue

• Constructor CXmlQueue: establece el nombre inicial del archivo donde se almacena la cola.
  
• SetCurrentBuild: escribe información sobre la compilación actual en el archivo XML de la cola. Este es un elemento que no está en la cola; almacena información sobre el proceso actualmente en ejecución. Puede estar vacio
  
• GetCurrentBuild: obtiene los parámetros del proceso en ejecución del archivo XML de cola. Puede estar vacio
  
• ClearCurrentBuild: borra el elemento de construcción actual en el archivo XML de cola si el proceso finaliza.
  
• OpenXmlQueue: función para abrir el archivo XML donde se almacena la cola. Si falta el archivo, se crea uno nuevo.
  
• GetLastQueueBuildNumber: cada compilación en la cola tiene su propio número de serie único. Esta función devuelve su valor, que se almacena en el atributo raíz.
  
• IncrementLastQueueBuildNumber: aumenta el valor del número de compilación al poner en cola una nueva compilación.
  
• GetCurrentQueue: devuelve una lista de elementos QBuildRecord del archivo XML de la cola.
  

 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> 

Agregar clase de funciones auxiliares

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

Agregar nuevas funciones a la interfaz de servicio

• PushBuild (QBuildRecord): nulo. Esta es una función que agrega un nuevo valor al archivo XML de cola con los parámetros QBuildRecord
  
• TestPushBuild (): nulo. Esta es una función de prueba que agrega datos de prueba a una cola en un archivo XML.
  
• PullBuild: QBuildRecord. Esta es una función que recupera el valor QBuildRecord del archivo XML de la cola. Puede estar vacio.
  

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

Implementamos funciones en la clase 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" } ); } } 

Realizar cambios en AppQueueWindowsService: clase 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> 

Resultados