public override ResponseMessage RunDataService(RequestMessage requestMessage) {
using(var client = new WcfDataService.DataServiceClient()) {
var requestBytes = DataServiceTool.ResolveRequestSerializer(ProductName).Serialize(requestMessage);
var responseBytes = client.Execute(requestBytes, ProductName);
return DataServiceTool.ResolveResponseSerializer(ProductName).Deserialize(responseBytes);
}
}
public static Task<ResponseMessage> Execute(this WebClient client,
RequestMessage requestMessage,
Uri uri,
string productName,
TaskCompletionSource<string> tcs) {
client.ShouldNotBeNull("client");
requestMessage.ShouldNotBeNull("requestMessage");
try {
var responseText = ResolveRequestSerializer(productName).Serialize(requestMessage).Base64Encode();
return
client
.UploadStringTask(uri, "POST", responseText)
.ContinueWith(task => {
var responseBytes = task.Result;
return ResolveResponseSerializer(productName).Deserialize(responseBytes.Base64Decode());
});
}
catch(Exception ex) {
if(log.IsErrorEnabled)
log.ErrorException("WebClient를 통한 요청이 실패했습니다.", ex);
throw;
}
}
public static Task<ResponseMessage> ExecuteTask(this DataServiceClient client,
RequestMessage requestMessage,
string productName,
TaskCompletionSource<byte[]> tcs) {
client.ShouldNotBeNull("client");
requestMessage.ShouldNotBeNull("requestMessage");
try {
var requestBytes = ResolveRequestSerializer(productName).Serialize(requestMessage);
var asyncResult = client.BeginExecute(requestBytes, productName, null, null);
var executeTask = Task.Factory.StartNew(ar => client.EndExecute((IAsyncResult)ar),
asyncResult,
TaskCreationOptions.None);
return
executeTask
.ContinueWith(task => {
var responseBytes = executeTask.Result;
return ResolveResponseSerializer(productName).Deserialize(responseBytes);
});
}
catch(Exception ex) {
if(log.IsErrorEnabled)
log.ErrorException("WCF DataServiceClient를 통한 요청이 실패했습니다.", ex);
throw;
}
}
public override ResponseMessage RunDataService(RequestMessage requestMessage) {
using(var client = new WebDataService.DataService()) {
var requestBytes = DataServiceTool.ResolveRequestSerializer(ProductName).Serialize(requestMessage);
var tcs = new TaskCompletionSource<byte[]>();
ExecuteCompletedEventHandler handler = null;
handler =
(sender, args) =>
Parallelism.Tools.EventAsyncPattern.HandleCompletion(tcs, args, () => args.Result,
() => client.ExecuteCompleted -= handler);
client.ExecuteCompleted += handler;
try {
client.ExecuteAsync(requestBytes, ProductName, tcs);
}
catch(Exception ex) {
if(log.IsErrorEnabled)
log.ErrorException("웹서비스 비동기 호출에 예외가 발생했습니다.", ex);
client.ExecuteCompleted -= handler;
tcs.TrySetException(ex);
}
var responseBytes = tcs.Task.Result;
return DataServiceTool.ResolveResponseSerializer(ProductName).Deserialize(responseBytes);
}
}
public static Task<ResponseMessage> ExecuteTask(this DataService client,
RequestMessage requestMessage,
string productName,
TaskCompletionSource<byte[]> tcs) {
client.ShouldNotBeNull("client");
requestMessage.ShouldNotBeNull("requestMessage");
try {
var requestBytes = ResolveRequestSerializer(productName).Serialize(requestMessage);
ExecuteCompletedEventHandler handler = null;
handler = (sender, e) => EAPCommon.HandleCompletion(tcs, e, () => e.Result, () => client.ExecuteCompleted -= handler);
client.ExecuteCompleted += handler;
client.ExecuteAsync(requestBytes, productName, tcs);
return
tcs.Task
.ContinueWith(task => ResolveResponseSerializer(productName).Deserialize(task.Result));
}
catch(Exception ex) {
if(log.IsErrorEnabled)
log.ErrorException("웹서비스를 통한 요청이 실패했습니다.", ex);
throw;
}
}
/// <summary>
/// DATA 처리를 위한 요청정보를 처리해서, 응답정보를 빌드해서 반환합니다.
/// </summary>
/// <param name="requestMessage">요청 메시지</param>
/// <returns>응답 메시지</returns>
public virtual ResponseMessage Execute(RequestMessage requestMessage) {
var responseMsg = new ResponseMessage();
if(IsDebugEnabled)
log.Debug("요청정보에 따른 작업을 시작합니다...");
if(requestMessage == null) {
if(log.IsWarnEnabled)
log.Warn("요청 정보가 NULL입니다.");
responseMsg.Errors.Add(new ErrorMessage { Code = 0, Message = DataServiceTool.NoRequestProvided });
return responseMsg;
}
TransactionScope txScope = null;
try {
// 1. 사전 작업
//
responseMsg.MessageId = requestMessage.MessageId;
if(requestMessage.Transactional) {
if(IsDebugEnabled)
log.Debug("요청작업이 Transaction을 필요로 하여, Transaction을 시작합니다...");
txScope = AdoTool.CreateTransactionScope(TransactionScopeOption.Required, IsolationLevel.ReadCommitted);
}
//
// 2. 본 작업
//
ExecuteInternal(requestMessage, responseMsg);
// 3. 사후 작업
//
if(txScope != null) {
txScope.Complete();
if(IsDebugEnabled)
log.Debug("요청작업의 Transaction을 Commit 했습니다.");
}
}
catch(Exception ex) {
responseMsg.AddError(ex);
if(log.IsErrorEnabled)
log.Error("요청정보에 따른 작업처리 중 예외가 발생했습니다.", ex);
if(txScope != null)
txScope.Dispose();
}
if(IsDebugEnabled)
log.Debug("요청정보에 따른 작업을 완료했습니다!!! Request MessageId=[{0}], Response MessageId=[{1}]", requestMessage.MessageId,
responseMsg.MessageId);
return responseMsg;
}
public override ResponseMessage RunDataService(RequestMessage requestMessage) {
using(var client = new WebClient()) {
var requestBytes = DataServiceTool.ResolveRequestSerializer(ProductName).Serialize(requestMessage);
var responseText = client.UploadStringTask(GetScriptUrl(), "POST", requestBytes.Base64Encode()).Result;
return DataServiceTool.ResolveResponseSerializer(ProductName).Deserialize(responseText.Base64Decode());
}
}
public override ResponseMessage RunDataService(RequestMessage requestMessage) {
using(var client = new WcfDataService.DataServiceClient()) {
var requestBytes = DataServiceTool.ResolveRequestSerializer(ProductName).Serialize(requestMessage);
var asyncResult = client.BeginExecute(requestBytes, ProductName, null, null);
var task = Task.Factory.StartNew(ar => client.EndExecute((IAsyncResult)ar), asyncResult, TaskCreationOptions.None);
return DataServiceTool.ResolveResponseSerializer(ProductName).Deserialize(task.Result);
}
}
public static ResponseMessage Execute(this DataServiceClient client, RequestMessage requestMessage, string productName) {
client.ShouldNotBeNull("client");
requestMessage.ShouldNotBeNull("requestMessage");
try {
var requestBytes = ResolveRequestSerializer(productName).Serialize(requestMessage);
var responseBytes = client.Execute(requestBytes, productName);
return ResolveResponseSerializer(productName).Deserialize(responseBytes);
}
catch(Exception ex) {
if(log.IsErrorEnabled)
log.ErrorException("WCF DataServiceClient를 통한 요청이 실패했습니다.", ex);
throw;
}
}
protected override void DoProcessRequestItems(RequestMessage requestMessage, ResponseMessage responseMessage) {
// 요청작업이 병렬로 처리해서는 안될 경우를 대비
//
if(requestMessage.AsParallel == false) {
base.DoProcessRequestItems(requestMessage, responseMessage);
return;
}
if(IsDebugEnabled)
log.Debug("요청 항목들을 병렬로 처리합니다...");
// 병렬로 작업을 처리하고, 응답메시지에 추가합니다.
requestMessage.Items
.AsParallel()
.AsOrdered()
.ForAll(requestItem => {
var responseItem = DoProcessRequestItem(requestItem);
responseMessage.Items.Add(responseItem);
});
}
public static ResponseMessage Execute(this WebClient client,
RequestMessage requestMessage,
Uri uri,
string productName) {
client.ShouldNotBeNull("client");
requestMessage.ShouldNotBeNull("requestMessage");
try {
var responseText = ResolveRequestSerializer(productName).Serialize(requestMessage).Base64Encode();
var responsesText = client.UploadString(uri, "POST", responseText);
return ResolveResponseSerializer(productName).Deserialize(responsesText.Base64Decode());
}
catch(Exception ex) {
if(log.IsErrorEnabled)
log.ErrorException("WebClient를 통한 요청이 실패했습니다.", ex);
throw;
}
}
/// <summary>
/// HttpHandler의 작업의 메인 메소드입니다. 재정의 하여 원하는 기능을 수행하되, 제일 첫번째에 부모 클래스의 메소들를 호출해주어야 합니다.
/// </summary>
/// <param name="context"></param>
protected override void DoProcessRequest(HttpContext context) {
context.ShouldNotBeNull("context");
if(IsDebugEnabled)
log.Debug(@"JSON TEXT 형식의 요청에 대해 작업 후, JSON TEXT 문자열로 반환합니다.");
try {
var productName = context.Request[HttpParams.Product].AsText();
var method = context.Request[HttpParams.Method].AsText();
var responseFormat = context.Request[HttpParams.ResponseFormat].AsEnum(ResponseFormatKind.ResultSet);
if(IsDebugEnabled)
log.Debug("ProductName=[{0}], Method=[{1}], ResponseFormat=[{2}] 에 대한 요청 처리를 접수했습니다...",
productName, method, responseFormat);
var requestMessage = new RequestMessage();
requestMessage.AddItem(method, responseFormat);
var dataService = DataServiceTool.ResolveDataService(productName);
var responseMessage = dataService.Execute(requestMessage);
var responseText = JsonTool.SerializeAsText(responseMessage);
var responseBytes = Compressor.Compress(responseText.ToBytes());
context.WriteResponse(responseBytes);
//var response = context.Response;
//response.OutputStream.Write(responseBytes, 0, responseBytes.Length);
//response.OutputStream.Flush();
if(IsDebugEnabled)
log.Debug("ProductName=[{0}], Method=[{1}]에 대한 요청 처리를 완료하였습니다!!!", productName, method);
}
catch(Exception ex) {
if(log.IsErrorEnabled)
log.Error("요청을 처리하는 동안 예외가 발생했습니다.", ex);
}
}
/// <summary>
/// Client 종류별로 설정할 내용입니다.
/// </summary>
/// <param name="requestMessage"></param>
/// <returns></returns>
public virtual ResponseMessage RunDataService(RequestMessage requestMessage) {
return DataService.Execute(requestMessage);
}
public override ResponseMessage RunDataService(RequestMessage requestMessage) {
return
Task.Factory
.StartNew(() => DataService.Execute(requestMessage), TaskCreationOptions.PreferFairness)
.Result;
// return DelegateAsync.Run(msg => DataService.Execute(msg), requestMessage, null).Result;
}
/// <summary>
/// <paramref name="requestMessage"/>의 Method 를 서버에서 관련 Query 문장으로 매핑합니다.
/// </summary>
public static void LoadQueryStatements(this IDataService dataService, RequestMessage requestMessage) {
if(IsDebugEnabled)
log.Debug("요청 메시지의 모든 요청 정보를 서버의 설정 쿼리문으로 매핑합니다... requestMessage.MessageId=[{0}]", requestMessage.MessageId);
dataService.AssertDataService();
requestMessage.ShouldNotBeNull("requestMessage");
var queryProvider = dataService.AdoRepository.QueryProvider;
// 1. 전체 메시지의 사전 작업
foreach(var method in requestMessage.PrepareStatements)
requestMessage.PreQueries.Add(queryProvider.GetQueryString(method, method));
// 2. 요청 항목 별
foreach(var requestItem in requestMessage.Items) {
if(IsDebugEnabled)
log.Debug("요청 메소드에 해당하는 실제 Query 문을 로드합니다... requestItem.Method=[{0}]", requestItem.Method);
foreach(var method in requestItem.PrepareStatements)
requestItem.PreQueries.Add(queryProvider.GetQueryString(method, method));
requestItem.Query = (requestItem.RequestMethod == RequestMethodKind.Method)
? queryProvider.GetQueryString(requestItem.Method, requestItem.Method)
: requestItem.Method;
foreach(var method in requestItem.PostscriptStatements)
requestItem.PostQueries.Add(queryProvider.GetQueryString(method, method));
}
// 3. 전체 메시지의 사후 작업
foreach(var method in requestMessage.PostscriptStatements)
requestMessage.PostQueries.Add(queryProvider.GetQueryString(method, method));
if(IsDebugEnabled)
log.Debug("요청 메소드에 해당하는 실제 Query 문을 로드했습니다!!!");
}
protected virtual void DoProcessRequestItems(RequestMessage requestMessage, ResponseMessage responseMessage) {
// 3. 요청 항목별로 작업 처리
foreach(var requestItem in requestMessage.Items) {
var responseItem = DoProcessRequestItem(requestItem);
responseMessage.Items.Add(responseItem);
}
}
protected virtual void ExecuteInternal(RequestMessage requestMessage, ResponseMessage responseMessage) {
if(IsDebugEnabled)
log.Debug("요청 항목 순서대로 작업을 처리합니다.");
// 1. 요청 메소드의 실제 Query 문을 매핑합니다.
DataServiceTool.LoadQueryStatements(this, requestMessage);
// 2. 요청 메시지 전체에 대한 사전 작업 수행
ExecuteQueries(requestMessage.PreQueries);
// 3. 요청 항목별로 작업 처리
DoProcessRequestItems(requestMessage, responseMessage);
// 4. 요청 메시지 전체에 대한 사후 작업 수행
ExecuteQueries(requestMessage.PostQueries);
}
/// <summary>
/// DATA 처리를 위한 요청정보를 처리해서, 응답정보를 빌드해서 반환합니다.
/// </summary>
/// <param name="requestMessage">요청 메시지</param>
/// <returns>응답 메시지</returns>
public static ResponseMessage Execute(RequestMessage requestMessage) {
return Instance.Execute(requestMessage);
}
