WCF4.0 –- RESTful WCF Services (实例) (并发同步服务 SyncService)

最近写自动化测试时遇到一个问题： 我们在进行一个并发测试的过程中，需要所有客户端测试代码，在某个时机同步。回想所学到的，线程同步手段很多了，同一台PC上的进程间同步也可以通过Metux实现，多PC的时候怎么办。因为最近在学习REST WCF，自然想到它，用它来做个同步服务，即可以解决多线程，多进程，多PC同步，还可以支持跨语言，真是一举多得。(类似的解决方案还有PNUNIT，它是通过.Net Remoting实现的，因为它还要写配置，还要起Lancher/Agent，有点烦)。

1. SyncService 的主要功能——Barrier(栏栅)：

借用PNUNIT的概念Barrier，也就是异步过程中的同步点，进到Barrier里的所有对象都要等待其他对象进入。这些对象可以是不同的线程，进程(不同PC，不同语言实现的客户端)，过程如下图：3个客户端启动之后，有快有慢，但是在Barrier处进行一次同步，先到的等待后到的。

举个实际例子： 假如我们要实现两个客户端通信的功能的测试，必须是两个客户端同时上线。那么我们可以在代码中设计一个barrier，让双方都确认上线之后，再进行通信测试。
(1) 准备Barrier

[c-sharp] view plaincopyprint?

1. var init = SyncService.Init("Barrier_Logon","Client1", "Client2"); 
2. // 启动Client1 
3. Process.Start("Client1.exe"); 
4. // 启动Client2 
5. Process.Start("Client2.exe"); 

var init = SyncService.Init("Barrier_Logon", "Client1", "Client2");// 启动Client1Process.Start("Client1.exe");// 启动Client2Process.Start("Client2.exe");
(2) Client1

[c-sharp] view plaincopyprint?

1. // client1登录 
2. var client1 = Login("Client1"); 
3. // 同步，等待Client2登录 
4. var enter = SyncService.Enter("Barrier_Logon","Client1"); 
5. // client1 和 client2 相互通信 ...  

// client1登录var client1 = Login("Client1");// 同步，等待Client2登录var enter = SyncService.Enter("Barrier_Logon", "Client1");// client1 和 client2 相互通信 ...
(3) Client2 和 Client1 类似

[c-sharp] view plaincopyprint?

1. // client2登录 
2. var client2 = Login("Client2"); 
3. // 同步，等待Client1登录 
4. var enter = SyncService.Enter("Barrier_Logon","Client2"); 
5. // client1 和 client2 相互通信 ...  

// client2登录var client2 = Login("Client2");// 同步，等待Client1登录var enter = SyncService.Enter("Barrier_Logon", "Client2");// client1 和 client2 相互通信 ...

2. SyncService 的消息交换功能——SetMessage/GetMessage：
我们还可以通过SyncService中的消息容器进行消息传递。如下图：

在异步的两段代码中，设置同步点，保证 GetMessage 是在 SetMessage 之后发生。这一点是并行测试中是很常见的处理。
Client1的代码：

[c-sharp] view plaincopyprint?

1. // 设置消息给client2 
2. var set = SyncService.SetMessage("Barrier","key", "hello client2"); 
3. // 进入Barrier, 等待client2 
4. var enter = SyncService.Enter("Barrier","Client1"); 

// 设置消息给client2var set = SyncService.SetMessage("Barrier", "key", "hello client2");// 进入Barrier, 等待client2var enter = SyncService.Enter("Barrier", "Client1");
Client2的代码：

[c-sharp] view plaincopyprint?

1. // 进入Barrier,等待client1 
2. var enter = SyncService.Enter("Barrier","Client2"); 
3. // 取得消息 
4. var get = SyncService.GetMessage("Barrier","key"); 
5. // 确认获得消息，是"hello client2" 
6. Assert.AreEqual(get, "hello client2"); 

// 进入Barrier,等待client1var enter = SyncService.Enter("Barrier", "Client2");// 取得消息var get = SyncService.GetMessage("Barrier", "key");// 确认获得消息，是"hello client2"Assert.AreEqual(get, "hello client2");

3. SyncService的实现
如果上面的并行处理代码理解了的话，SyncService的实现就很好推断出来了。服务端维护一个Dictionary<string, SyncGroup>的容器，每个客户端Enter时，调用对应的ManualResetEvent.Set()解锁。然后WaitAll其他的ManualResetEvent，从而实现同步。

[c-sharp] view plaincopyprint?

1. using System; 
2. using System.Collections.Generic; 
3. using System.Linq; 
4. using System.ServiceModel; 
5. using System.ServiceModel.Activation; 
6. using System.ServiceModel.Web; 
7. using System.Text; 
8. using System.Threading; 
9. using System.Runtime.Serialization; 
10.  
11. namespace SyncService 
12. { 
13.     [ServiceContract] 
14.     [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)] 
15.     [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall)] 
16.     public class SyncService 
17.     { 
18.         private static Dictionary<string, SyncGroup> _syncPool =new Dictionary<string, SyncGroup>(); 
19.  
20.         [WebGet(UriTemplate="Init/{barrier}/{targetnames}")] 
21.         public string Init(string barrier,string targetnames) 
22.         { 
23.             var ctx = WebOperationContext.Current; 
24.             try 
25.             { 
26.                 lock (_syncPool) 
27.                 { 
28.                     _syncPool[barrier] = new SyncGroup(); 
29.                     var syncGroup = _syncPool[barrier]; 
30.                     var targets = targetnames.Split(new[] {',' }, StringSplitOptions.RemoveEmptyEntries); 
31.                     Array.ForEach(targets, t => syncGroup.ResetEventDict.Add(t,new ManualResetEvent(false))); 
32.                 } 
33.                 return "ok"; 
34.             } 
35.             catch (Exception ex) 
36.             { 
37.                 return ex.Message; 
38.             } 
39.         } 
40.  
41.         [WebGet(UriTemplate = "Enter/{barrier}/{targetname}/{timeout=60000}")] 
42.         public string Enter(string barrier,string targetname, string timeout) 
43.         { 
44.             var ctx = WebOperationContext.Current; 
45.             try 
46.             { 
47.                 var syncObj = _syncPool[barrier]; 
48.                 var target = syncObj.ResetEventDict[targetname]; 
49.                 target.Set(); 
50.                 var intTimeout = int.Parse(timeout); 
51.                 var success = WaitHandle.WaitAll(syncObj.ResetEventDict.Values.ToArray(), intTimeout); 
52.                 if (success) 
53.                     return"ok"; 
54.                 else 
55.                     return"timeout"; 
56.             } 
57.             catch (Exception ex) 
58.             { 
59.                 return ex.Message; 
60.             } 
61.         } 
62.  
63.         [WebGet(UriTemplate = "SetMessage/{barrier}/{key}/{message=null}")] 
64.         public string SetMessage(string barrier,string key, string message) 
65.         { 
66.             var ctx = WebOperationContext.Current; 
67.             try 
68.             { 
69.                 var syncObj = _syncPool[barrier]; 
70.                 lock (syncObj) 
71.                 { 
72.                     var query = syncObj.Messages.FirstOrDefault(m => m.Key == key); 
73.                     syncObj.Messages.Remove(query); 
74.                     var messageInfo = new MessageInfo 
75.                     { 
76.                         BarrierName = barrier, 
77.                         Key = key, 
78.                         Message = message, 
79.                         UpdateDateTime = DateTime.Now 
80.                     }; 
81.                     syncObj.Messages.Add(messageInfo); 
82.                 } 
83.                 return "ok"; 
84.             } 
85.             catch (Exception ex) 
86.             { 
87.                 return ex.Message; 
88.             } 
89.         } 
90.  
91.         [WebGet(UriTemplate = "GetMessage/{barrier}/{key}")] 
92.         public string GetMessage(string barrier,string key) 
93.         { 
94.             var ctx = WebOperationContext.Current; 
95.             try 
96.             { 
97.                 var syncObj = _syncPool[barrier]; 
98.                 var query = syncObj.Messages.FirstOrDefault(m => m.Key == key); 
99.                 return query.Message; 
100.             } 
101.             catch (Exception ex) 
102.             { 
103.                 return ex.Message; 
104.             } 
105.         } 
106.  
107.         [WebGet(UriTemplate = "ListMessages/{barrier=all}", ResponseFormat=WebMessageFormat.Xml)] 
108.         public List<MessageInfo> ListMessages(string barrier) 
109.         { 
110.             var ctx = WebOperationContext.Current; 
111.             try 
112.             { 
113.                 var messages = new List<MessageInfo>(); 
114.                 if (barrier == "all") 
115.                     _syncPool.Values.ToList().ForEach(t => messages.AddRange(t.Messages)); 
116.                 else 
117.                     messages = _syncPool[barrier].Messages; 
118.                 return messages; 
119.             } 
120.             catch 
121.             { 
122.                 return null; 
123.             } 
124.         } 
125.  
126.         [WebGet(UriTemplate="Check", ResponseFormat=WebMessageFormat.Xml)] 
127.         public string Check() 
128.         { 
129.             return "Welcome to the SyncService! " +  
130.                 DateTime.Now.ToLongDateString() + " " + DateTime.Now.ToLongTimeString(); 
131.         } 
132.              
133.     } 
134.  
135.     [DataContract] 
136.     [KnownType(typeof(MessageInfo))] 
137.     public class SyncGroup 
138.     { 
139.         internal Dictionary<string, ManualResetEvent> ResetEventDict {get; set; } 
140.         [DataMember] 
141.         public string Name {get; set; }    
142.         [DataMember] 
143.         public List<MessageInfo> Messages {get; set; } 
144.         [DataMember] 
145.         public Dictionary<string,string> States { get;set; } 
146.  
147.         public SyncGroup() 
148.         { 
149.             Messages = new List<MessageInfo>(); 
150.             ResetEventDict = new Dictionary<string, ManualResetEvent>(); 
151.         } 
152.     } 
153.  
154.     [DataContract] 
155.     public class MessageInfo 
156.     { 
157.         [DataMember] 
158.         public string BarrierName {get; set; } 
159.         [DataMember] 
160.         public string Key {get; set; } 
161.         [DataMember] 
162.         public string Message {get; set; } 
163.         [DataMember] 
164.         public string Identity {get; set; } 
165.         [DataMember] 
166.         public DateTime UpdateDateTime {get; set; } 
167.     } 
168. } 

using System;using System.Collections.Generic;using System.Linq;using System.ServiceModel;using System.ServiceModel.Activation;using System.ServiceModel.Web;using System.Text;using System.Threading;using System.Runtime.Serialization;namespace SyncService{ [ServiceContract] [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)] [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall)] public class SyncService { private static Dictionary<string, SyncGroup> _syncPool = new Dictionary<string, SyncGroup>(); [WebGet(UriTemplate="Init/{barrier}/{targetnames}")] public string Init(string barrier, string targetnames) { var ctx = WebOperationContext.Current; try { lock (_syncPool) { _syncPool[barrier] = new SyncGroup(); var syncGroup = _syncPool[barrier]; var targets = targetnames.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries); Array.ForEach(targets, t => syncGroup.ResetEventDict.Add(t, new ManualResetEvent(false))); } return "ok"; } catch (Exception ex) { return ex.Message; } } [WebGet(UriTemplate = "Enter/{barrier}/{targetname}/{timeout=60000}")] public string Enter(string barrier, string targetname, string timeout) { var ctx = WebOperationContext.Current; try { var syncObj = _syncPool[barrier]; var target = syncObj.ResetEventDict[targetname]; target.Set(); var intTimeout = int.Parse(timeout); var success = WaitHandle.WaitAll(syncObj.ResetEventDict.Values.ToArray(), intTimeout); if (success) return "ok"; else return "timeout"; } catch (Exception ex) { return ex.Message; } } [WebGet(UriTemplate = "SetMessage/{barrier}/{key}/{message=null}")] public string SetMessage(string barrier, string key, string message) { var ctx = WebOperationContext.Current; try { var syncObj = _syncPool[barrier]; lock (syncObj) { var query = syncObj.Messages.FirstOrDefault(m => m.Key == key); syncObj.Messages.Remove(query); var messageInfo = new MessageInfo { BarrierName = barrier, Key = key, Message = message, UpdateDateTime = DateTime.Now }; syncObj.Messages.Add(messageInfo); } return "ok"; } catch (Exception ex) { return ex.Message; } } [WebGet(UriTemplate = "GetMessage/{barrier}/{key}")] public string GetMessage(string barrier, string key) { var ctx = WebOperationContext.Current; try { var syncObj = _syncPool[barrier]; var query = syncObj.Messages.FirstOrDefault(m => m.Key == key); return query.Message; } catch (Exception ex) { return ex.Message; } } [WebGet(UriTemplate = "ListMessages/{barrier=all}", ResponseFormat=WebMessageFormat.Xml)] public List<MessageInfo> ListMessages(string barrier) { var ctx = WebOperationContext.Current; try { var messages = new List<MessageInfo>(); if (barrier == "all") _syncPool.Values.ToList().ForEach(t => messages.AddRange(t.Messages)); else messages = _syncPool[barrier].Messages; return messages; } catch { return null; } } [WebGet(UriTemplate="Check", ResponseFormat=WebMessageFormat.Xml)] public string Check() { return "Welcome to the SyncService! " + DateTime.Now.ToLongDateString() + " " + DateTime.Now.ToLongTimeString(); } } [DataContract] [KnownType(typeof(MessageInfo))] public class SyncGroup { internal Dictionary<string, ManualResetEvent> ResetEventDict { get; set; } [DataMember] public string Name { get; set; } [DataMember] public List<MessageInfo> Messages { get; set; } [DataMember] public Dictionary<string, string> States { get; set; } public SyncGroup() { Messages = new List<MessageInfo>(); ResetEventDict = new Dictionary<string, ManualResetEvent>(); } } [DataContract] public class MessageInfo { [DataMember] public string BarrierName { get; set; } [DataMember] public string Key { get; set; } [DataMember] public string Message { get; set; } [DataMember] public string Identity { get; set; } [DataMember] public DateTime UpdateDateTime { get; set; } }}

默认使用JSON格式，另外为了查看当前的同步的状况和消息，可以通过 ListStates/ListMessages 查看。
(1) 初始化Barrier则发送： http://server/SyncService/Init/MyBarrier/Client1,Client2
(2) 客户端进入Barrier则发送: http://server/SyncService/Enter/MyBarrier/Client1/10000 (最后是timeout设定)
(3) 设置消息则发送: http://server/SyncService/SetMessage/MyBarrier/Key/MessageContent
(4) 取得消息则发送: http://server/SyncService/GetMessage/MyBarrier/Key
(5) 查看所有的“锁”则发送：http://server/SyncService/ListStates(或者指定某个Barrier: /MyBarrier)
(6) 查看所有的消息则发送：http://server/SyncService/ListMessages(或者指定某个Barrier: /MyBarrier)
(7) 清空所有SyncGroup则发送：http://server/SyncService/Restart

是的，全部的操作全部是 HttpRequest 的"GET", 因此各种客户端都可以轻松调用，很方便。 (用WCF创建这样一个服务也非常简单全部代码一百多行，正所谓天下武功无快不破:)

---

【REST WCF系列】
RESTful WCF Services (1) (入门)
RESTful WCF Services (2) (实现增，删，改，查)
RESTful WCF Services (3) (Raw Stream)
RESTful WCF Services (4) (Basic Security)
RESTful WCF Services (实例) (并发同步服务 SyncService)