WCF पर सरल लिपियों से लेकर स्वयं-ग्राहक-सर्वर अनुप्रयोग तक: मुझे CM में काम करना क्यों पसंद है

ऑटोमेशन एक बार या 117 पेज से अधिक का निर्देश

विन्यास प्रबंधन - नया रोमांच

डेवलपर्स क्या चाहते थे

• ठीक करने में असमर्थ कतार। निजी फिक्स खत्म होने पर विधानसभा को देखने के लिए आपको लगातार वेब पेज की जांच करनी होगी और आप अपना निर्माण शुरू कर सकते हैं।
  
• त्रुटियों के बारे में कोई सूचना नहीं है - असेंबली एप्लिकेशन के जीयूआई में त्रुटियों को देखने के लिए, आपको सर्वर पर जाना होगा और बहुत सारे स्वैच्छिक लॉग देखना होगा।
  
• निजी फ़िक्सेस के लिए कोई बिल्ड इतिहास नहीं है।
  

निजी सुधार क्या हैं

• चेक-इन - सोर्स कोड में स्थानीय परिवर्तन का एक सेट, जो TFS में संग्रहीत कोड के लिए बनाया गया है। इस चेक को कंटीन्यूअस इंटीग्रेशन / गेटेड चेक-इन प्रक्रियाओं का उपयोग करके चेक किया जा सकता है जो आपको केवल सही कोड को छोड़ने और अंतिम प्रोजेक्ट के संग्रह का उल्लंघन करने वाले सभी चेक को अस्वीकार करने की अनुमति देता है।
  
• अलमारियाँ - स्रोत कोड में स्थानीय परिवर्तनों का एक सेट जो सीधे TFS में स्थित स्रोत कोड के लिए नहीं बनाया गया है, लेकिन उनके नाम से सुलभ है। शेलसेट को डेवलपर की स्थानीय मशीन पर तैनात किया जा सकता है या टीएफएस में शामिल नहीं किए गए संशोधित कोड के साथ काम करने के लिए सिस्टम का निर्माण कर सकता है। इसके अलावा, शेलसेट को टीएफएस में तैनाती के बाद एक चेक के रूप में जोड़ा जा सकता है, जब इसके साथ सभी काम पूरा हो जाता है। उदाहरण के लिए, गेट-चेकर इस तरह से काम करता है। सबसे पहले, बिल्डर पर शेलसेट की जाँच की जाती है। यदि जाँच सफल होती है, तो शेल्केट चेक में बदल जाता है!
  

1. शेलसेट का नाम (संख्या) प्राप्त करता है और इसे निजी फ़िक्स्ड बिल्डर पर भेजता है। नतीजतन, हमें रिलीज़ उत्पाद का स्रोत कोड प्राप्त होता है और शेलसेट से परिवर्तन / सुधार होते हैं। रिलीज शाखा अपरिवर्तित बनी हुई है।
   
2. एक निजी फिक्स बिल्डर पर, एक परियोजना या परियोजनाओं की एक श्रृंखला चल रही है, जिसके लिए एक निजी फिक्स का प्रदर्शन किया गया है।
   
3. संकलित बाइनरी फ़ाइलों के सेट को निजी फिक्स के नेटवर्क निर्देशिका में कॉपी किया जाता है। कैटलॉग में शेलसेट नाम है, जो संख्याओं का एक क्रम है।
   
4. निजी फिक्स बिल्डर पर स्रोत कोड को उसके मूल रूप में बहाल किया जाता है।
   

मेरा क्या था?

• एक निजी फिक्स बिल्डर, जो दिए गए कमांड लाइन मापदंडों के साथ एक कंसोल एप्लिकेशन लॉन्च करके TFS शेलसेट से निजी फिक्स एकत्र करता है।
  
• Veeam.Builder.Agent - वेम द्वारा लिखित WCF सेवा, जो वर्तमान उपयोगकर्ता के तहत कंसोल मोड में मापदंडों के साथ एप्लिकेशन लॉन्च करती है और एप्लिकेशन की वर्तमान स्थिति को लौटाती है।
  
• IIS वेब सेवा विंडोज फॉर्म पर एक एप्लिकेशन है जो आपको शेलसेट नाम, निर्दिष्ट मापदंडों को दर्ज करने और एक निजी फिक्स के निर्माण की प्रक्रिया शुरू करने की अनुमति देता है।
  
• एक बहुत ही उथले प्रोग्रामिंग ज्ञान C ++ है, जो विश्वविद्यालय में C # का एक सा है, और स्वचालन के लिए छोटे अनुप्रयोगों को लिखना, वर्तमान निर्माण प्रक्रियाओं में नए कार्यों को जोड़ना और एक शौक के रूप में है।
  
• अनुभवी सहकर्मी, Google और भारतीय MSDN सभी सवालों के जवाब के स्रोत हैं।
  

हम क्या करेंगे

• QBuilder.AppQueue मेरी WCF सेवा है जो बिल्ड कतार के साथ काम प्रदान करती है और बिल्ड प्रोग्राम को चलाने के लिए Veeam.Builder.Agent सेवा को कॉल करती है।
  
• dummybuild.exe डिबगिंग के लिए और दृश्य सहायता के रूप में उपयोग किया जाने वाला स्टब प्रोग्राम है। हस्तांतरित मापदंडों की कल्पना करने की आवश्यकता है।
  
• QBuilder.AppLauncher - WCF सेवा जो वर्तमान उपयोगकर्ता के कंसोल में एप्लिकेशन चलाती है और इंटरैक्टिव मोड में काम करती है। यह विशेष रूप से इस लेख के लिए लिखे गए Veeam.Builder.Agent प्रोग्राम का एक काफी सरल एनालॉग है। मूल सेवा विंडोज सेवा के रूप में काम कर सकती है और कंसोल में एप्लिकेशन चला सकती है, जिसे विंडोज एपीआई के साथ अतिरिक्त काम करने की आवश्यकता होती है। सभी ट्रिक्स का वर्णन करने के लिए, एक अलग लेख की आवश्यकता होगी। मेरा उदाहरण एक साधारण इंटरैक्टिव कंसोल सेवा के रूप में काम करता है और दो कार्यों का उपयोग करता है - मापदंडों के साथ एक प्रक्रिया शुरू करना और इसकी स्थिति की जांच करना।
  

WCF सेवाएँ बनाना

QBuilder.AppLauncher सेवा बनाएँ

1. QBuilder.AppLauncher नामक एक नया कंसोल एप्लिकेशन बनाएं
   
2. प्रोग्राम का नाम बदलें। Service.cs पर जाएं
   
3. नाम का नाम QBuilder.AppLauncher पर रखें
   
4. परियोजना के लिए निम्नलिखित संदर्भ जोड़ें:
   एक। System.ServiceModel.dll
   ख। System.ServiceProcess.dll
   सी। System.Configuration.Install.dll
   
5. निम्न परिभाषाएँ Service.cs में जोड़ें
   
   

   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; 

6. हम IAppLauncher इंटरफ़ेस को परिभाषित करते हैं और कतार के साथ काम करने के लिए फ़ंक्शन जोड़ते हैं:
   
   

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

7. AppLauncherService वर्ग में, हम इंटरफ़ेस और परीक्षण फ़ंक्शन को लागू करते हैं TestConnection:
   
   

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

8. एक नया AppLauncherWindowsService क्लास बनाएँ जो ServiceBase वर्ग को इनहेरिट करता है। ServiceHost का लिंक - स्थानीय वैरिएबल सर्विसहोस्ट को जोड़ें। हम मुख्य विधि को परिभाषित करते हैं, जिसे ServiceBase.Run (नया 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. OnStart () फ़ंक्शन को ओवरराइड करें जो नया 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. सर्विसहोस्ट उदाहरण को बंद करने वाले onStop फ़ंक्शन को ओवरराइड करें:
    
    

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

11. इंस्टालर से विरासत में मिली एक नई ProjectInstaller क्लास बनाएं और RunInstallerAttribute को चिह्नित करें, जो True पर सेट है। यह आपको 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. 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> 

सेवा की सेवाक्षमता की जाँच करना

1. हम सेवा संकलित करते हैं।
   
2. इसे installutil.exe कमांड से इंस्टॉल करें
   1) उस फ़ोल्डर पर जाएं जहां संकलित सेवा फ़ाइल निहित है
   2) स्थापना आदेश चलाएँ:
   C: \ Windows \ Microsoft.NET \ Framework64 \ v4.0.30319 \ InstallUtil.exe
3. हम सर्विसेज.एमएससी स्नैप-इन में जाते हैं, क्यूब्यूलर ऐप लॉन्चर सेवा की उपलब्धता की जांच करते हैं और इसे चलाते हैं।
   
4. हम WcfTestClient.exe प्रोग्राम का उपयोग करके सेवा की सेवाक्षमता की जांच करते हैं, जो VisualStudio के साथ शामिल है:
   
   1) WcfTestClient चलाएं
   2) सेवा पता जोड़ें: http: // localhost: 8000 / QBuilderAppLauncher / सेवा
   3) सेवा इंटरफ़ेस खुलता है:
   
   
   
   4) हम परीक्षण फ़ंक्शन को कॉल करते हैं TestConnection, जांचें कि सब कुछ काम करता है और फ़ंक्शन एक मान देता है:
   
   

मुझे एक परीक्षण फ़ंक्शन की आवश्यकता क्यों है जो कुछ भी नहीं करता है

कंसोल से चलने की क्षमता जोड़ें

1. AppLauncherWindowsService वर्ग में RunInteractive प्रक्रिया जोड़ें, जो कंसोल मोड में सेवा प्रदान करता है:
   
   

    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. हम मुख्य प्रक्रिया में परिवर्तन करते हैं - कमांड लाइन मापदंडों के प्रसंस्करण को जोड़ते हैं। / कंसोल विकल्प और एक सक्रिय उपयोगकर्ता सत्र के साथ, हम प्रोग्राम को इंटरैक्टिव मोड में लॉन्च करते हैं। अन्यथा, हम इसे एक सेवा के रूप में लॉन्च करते हैं।
   
   

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

एप्लिकेशन लॉन्च करने और उसकी स्थिति की जांच करने के लिए फ़ंक्शंस जोड़ें

1. सबसे पहले, वैश्विक वैरिएबल एपप्रोसेस को जोड़ें, जो वर्तमान में चल रही प्रक्रिया को संग्रहीत करता है।
   
   इसे public class AppLauncherService : IAppLauncher जोड़ें public class AppLauncherService : IAppLauncher :
   
   

    public class AppLauncherService : IAppLauncher   {       Process appProcess; 

2. फ़ंक्शन को उसी वर्ग में जोड़ें जो चल रही प्रक्रिया की स्थिति की जाँच करता है:
   
   

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

   
   फ़ंक्शन गलत हो जाता है यदि प्रक्रिया मौजूद नहीं है या पहले से ही चालू नहीं है, और यदि प्रक्रिया सक्रिय है तो सही है।
   
3. एप्लिकेशन लॉन्च करने के लिए फ़ंक्शन जोड़ें:
   
   

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

QBuilder.AppLauncher सेवा लॉन्च करना

1. काम करने के लिए, आपको QBuilder.AppLauncher.exe और QBuilder.AppLauncher.exe.config फाइलें चाहिए, जो ऊपर दिए गए लिंक पर संग्रह में हैं। स्व-विधानसभा के लिए इस एप्लिकेशन का स्रोत कोड भी वहां स्थित है।
   
2. हम व्यवस्थापक अधिकारों के साथ सेवा शुरू करते हैं।
   
3. सेवा की कंसोल विंडो खुलेगी:
   

1. परीक्षणों के लिए, wcftestclient.exe चलाएं, जो विज़ुअल स्टूडियो के साथ शामिल है। हम http: // localhost: 8000 / QBuilderAppLauncher / सेवा में सेवा की उपलब्धता की जांच करते हैं या इंटरनेट एक्सप्लोरर में लिंक खोलते हैं।
   

QBuilder.AppQueue सेवा बनाना

कतार सेवा में उपयोग के लिए QBuilder.AppLauncher सेवा के लिए एक लिंक जोड़ें

1. हमारी परियोजना के लिए समाधान एक्सप्लोरर में, सेवा संदर्भ जोड़ें और पता निर्दिष्ट करें: स्थानीयहोस्ट करें: 8000 / QBuilderAppLaaer / सेवा
   
2. नाम नाम स्थान का चयन करें: AppLauncherService।
   

कतार तत्वों को संग्रहीत करने के लिए एक संरचना बनाएं

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

CXmlQueue कतार वर्ग को लागू करना

• CXmlQueue कंस्ट्रक्टर - उस फ़ाइल का प्रारंभिक नाम सेट करता है जहाँ कतार संग्रहीत है।
  
• SetCurrentBuild - कतार XML फ़ाइल के वर्तमान निर्माण के बारे में जानकारी लिखता है। यह एक ऐसा तत्व है जो कतार में नहीं है, यह वर्तमान में चल रही प्रक्रिया के बारे में जानकारी संग्रहीत करता है। खाली हो सकता है।
  
• GetCurrentBuild - कतार XML फ़ाइल से चल रही प्रक्रिया के पैरामीटर हो जाता है। खाली हो सकता है।
  
• ClearCurrentBuild - यदि प्रक्रिया समाप्त हो जाती है, तो यह कतार XML फ़ाइल में वर्तमान तत्व को साफ़ करता है।
  
• OpenXmlQueue - XML ​​फ़ाइल को खोलने के लिए फ़ंक्शन जहां कतार संग्रहीत है। यदि फ़ाइल गुम है, तो एक नया बनाया जाता है।
  
• GetLastQueueBuildNumber - कतार में प्रत्येक बिल्ड का अपना विशिष्ट सीरियल नंबर है। यह फ़ंक्शन उसका मान लौटाता है, जो रूट विशेषता में संग्रहीत होता है।
  
• IncrementLastQueueBuildNumber - एक नई बिल्ड को पंक्तिबद्ध करते समय बिल्ड नंबर का मान बढ़ाता है।
  
• GetCurrentQueue - कतार XML फ़ाइल से QBuildRecord तत्वों की सूची लौटाता है।
  

 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> 

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

सेवा इंटरफ़ेस में नई सुविधाएँ जोड़ें

• PushBuild (QBuildRecord): शून्य। यह एक फ़ंक्शन है जो QBuildRecord मापदंडों के साथ कतार XML फ़ाइल में एक नया मान जोड़ता है
  
• TestPushBuild (): शून्य। यह एक परीक्षण फ़ंक्शन है जो XML फ़ाइल में एक कतार में परीक्षण डेटा जोड़ता है।
  
• PullBuild: QBuildRecord। यह एक फ़ंक्शन है जो कतार XML फ़ाइल से QBuildRecord मान प्राप्त करता है। यह खाली हो सकता है।
  

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

हम 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" } ); } } 

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 फ़ाइल को निर्देशिका में कॉपी करें, उदाहरण के लिए, c: \ temp में। यह कार्यक्रम एक परीक्षण स्टब है और बस कमांड लाइन मापदंडों को प्रदर्शित करता है जो सेवा लॉन्च किए जा रहे एप्लिकेशन को पास करता है। यदि आप किसी भिन्न निर्देशिका का उपयोग करते हैं, तो कॉन्फ़िगरेशन फ़ाइल में BuildToolPath और BuildToolWorkDir पैरामीटर बदलना सुनिश्चित करें।
   
3. \ QBuilder.AppLauncher \ binaries \ QBuilder.AppLauncher \ निर्देशिका पर जाएं और व्यवस्थापक मोड में QBuilder.AppLauncher.exe फ़ाइल चलाएँ। आप इस सेवा को स्रोत से भी संकलित कर सकते हैं।
   
4. हम प्रशासक अधिकारों के साथ QBuilder.AppQueue.exe / कंसोल कमांड के साथ संकलित सेवा का कंसोल संस्करण लॉन्च करते हैं।
   
5. जांचें कि सेवा शुरू हो गई है और काम कर रही है:
   
   
   
6. हम शुरू करते हैं और प्रतीक्षा करते हैं। यदि सब कुछ सफलतापूर्वक काम करता है, तो 30 सेकंड के बाद निम्न विंडो दिखाई देगी:
   
   
   
7. BuildQueue.xml फ़ाइल खोलें और देखें कि कतार कैसे घटती है और वर्तमान परिवर्तन का मूल्य:
   
   

    <?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. डमी कार्यक्रम के प्रत्येक समापन के बाद, प्रक्रिया का अंत नकली होता है, जिसके बाद कतार में अगला तत्व लॉन्च किया जाता है:
   
   

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

परिणाम