public static string CreateConnection(QSettingModel setting, bool isTransmitter)
{
var res = $"host={setting.ServerAddress}";
if (isTransmitter)
{
res += ";publisherConfirms=true";
}
if (setting.Timeout != null)
{
res += $";timeout={setting.Timeout.Value}";
}
if (!string.IsNullOrWhiteSpace(setting.UserName))
{
res += $";username={setting.UserName};password={setting.Password}";
}
if (!string.IsNullOrWhiteSpace(setting.VirtualHost))
{
res += $";virtualHost={setting.VirtualHost}";
}
return(res);
}
public static T Register(QSettingModel setting)
{
var res = CreateProxy(null);
(res as RPCTransmitter <T>)?.SetQueueName(setting);
return(res);
}
protected Receiver(QSettingModel qSetting)
{
SettingModel = qSetting;
var connectionString = QCreateConnectionString.CreateConnection(qSetting, false);
_bus = RabbitHutch.CreateBus(connectionString);
if (HaveRequestMessage)
{
_bus.RespondAsync <TRequest, TResponse>(HandleRequestMessage,
c => c.WithQueueName(qSetting.QueueName));
}
if (HaveSendMessage)
{
_bus.SubscribeAsync <TMessage>(
$"{qSetting.QueueName}_R",
HandleSendMessage,
c => c.WithQueueName($"{qSetting.QueueName}_R"));
}
}
public async Task Send(QSettingModel setting, QBaseMessage request)
{
CreateBus(setting);
await _bus.SendAsync(setting.QueueName + "_R", request);
}
public async Task <QBaseResponse> Request(QSettingModel setting, QBaseRequest request)
{
CreateBus(setting);
return(await _bus.RequestAsync <QBaseRequest, QBaseResponse>(request,
c => c.WithQueueName(setting.QueueName)));
}
private void CreateBus(QSettingModel setting)
{
var connectionString = QCreateConnectionString.CreateConnection(setting, true);
_bus = RabbitHutch.CreateBus(connectionString);
}
public static void AddWebReceiverService <THostedService>(this WindsorContainer container, QSettingModel qSetting)
where THostedService : WebServiceReceiver
{
var wr = new BaseWebServiceReceiver <THostedService>(qSetting);
wr.Start();
container.Register(Component.For <THostedService>());
}
public static void AddWebReceiverService(this IWindsorContainer container, QSettingModel qSetting)
{
var wr = new BaseWebReceiver(qSetting);
wr.Start();
}
//protected int? ReturnStatus = null;
//protected Dictionary<string, string> ReturnHeader = null;
public BaseWebServiceReceiver(QSettingModel qSetting) : base(qSetting)
{
}
private async Task <QWebResponse> SendRequest(QWebRequestMessage request, QSettingModel settingModel)
{
var res = new QWebResponse()
{
TraceId = request.TraceId
};
try
{
HttpMethod httpMethod;
switch (request.HttpMethod.ToUpper())
{
case "POST":
httpMethod = HttpMethod.Post;
break;
case "GET":
httpMethod = HttpMethod.Get;
break;
case "PUT":
httpMethod = HttpMethod.Put;
break;
case "DELETE":
httpMethod = HttpMethod.Delete;
break;
case "OPTIONS":
httpMethod = HttpMethod.Options;
break;
case "HEAD":
httpMethod = HttpMethod.Head;
break;
default:
httpMethod = HttpMethod.Get;
break;
}
var appSetting = IoC.Resolve <IAppSetting>();
var url = new Uri(appSetting.Get("EngineUrl"));
request.Domain = url.Authority;
request.Scheme = url.Scheme;
var message = new HttpRequestMessage(httpMethod,
new Uri(new Uri(request.BaseUrl),
$"{request.Arguments}{request.QueryStrings}"));
//Debugger.Break();
if (request.Headers?.Any() ?? false)
{
if (request.Headers.Any(k => k.Key == "Host"))
{
request.Headers.Remove("Host");
request.Headers.Add("Host", new[] { request.Domain });
}
if (request.Headers.ContainsKey("Content-Type") &&
request.Headers["Content-Type"][0].StartsWith("application/x-www-form-urlencoded"))
{
//message.Content = new StringContent(request.Body);
var items = HttpUtility.ParseQueryString(request.Body.FromBytes());
message.Content = new FormUrlEncodedContent(items.ToNameValueCollection <string, string>());
}
if (request.Headers.ContainsKey("Content-Type") &&
request.Headers["Content-Type"][0].StartsWith("multipart/form-data; boundary"))
{
var parser = MultipartFormDataParser.Parse(new MemoryStream(request.Body), Encoding.UTF8);
var cont = new MultipartFormDataContent();
foreach (var file in parser.Files ?? new List <FilePart>())
{
var f = new StreamContent(file.Data);
f.Headers.Add("Content-Disposition",
new string(Encoding.UTF8
.GetBytes($"form-data; name=\"{file.Name}\"; filename=\"{file.FileName}\"")
.Select(b => (char)b).ToArray()));
f.Headers.Add("Content-Type", file.ContentType);
if (!string.IsNullOrWhiteSpace(file.Name) && !string.IsNullOrWhiteSpace(file.FileName))
{
cont.Add(f, file.Name, file.FileName);
}
else if (!string.IsNullOrWhiteSpace(file.Name))
{
cont.Add(f, file.Name);
}
else
{
cont.Add(f);
}
}
foreach (var item in parser.Parameters ?? new List <ParameterPart>())
{
cont.Add(new StringContent(item.Data), item.Name);
}
message.Content = cont;
}
if (request.Headers.ContainsKey("Content-Type") &&
request.Headers["Content-Type"][0].StartsWith("application/json"))
{
message.Content = new StringContent(request.Body.FromBytes(), Encoding.UTF8,
request.Headers["Content-Type"][0]);
}
foreach (var header in request.Headers)
{
if (_blockedHeader.Contains(header.Key.ToLower()))
{
continue;
}
if (header.Key == "Content-Type" &&
header.Value[0].StartsWith("application/x-www-form-urlencoded"))
{
continue;
}
if (!string.IsNullOrWhiteSpace(
message
.Headers
.FirstOrDefault(d =>
string.Equals(d.Key, header.Key, StringComparison.CurrentCultureIgnoreCase)).Key))
{
message.Headers.Remove(header.Key);
message.Headers.Remove(header.Key.ToLower());
}
message.Headers.Add(header.Key, header.Value);
}
}
message.Headers.Add("MIP", request.IP);
var imp = Globals.GetImplementedInterfaceOf <IWebReceiverExt>();
if (imp?.Any() ?? false)
{
foreach (var item in imp)
{
item.BeforeSend(message, request);
}
}
var cancellationToken = new CancellationTokenSource();
cancellationToken.CancelAfter((settingModel.Timeout ?? 15 / 1000) * 1000);
var wRes = await RequestClient.SendAsync(message, cancellationToken.Token);
if (wRes == null)
{
return(res);
}
res.Status = (int)wRes.StatusCode;
res.Headers = new Dictionary <string, string[]>();
var headers =
wRes.Content.Headers.Select(k => new KeyValuePair <string, IEnumerable <string> >(k.Key, k.Value))
.ToList();
if (wRes.Headers != null)
{
var keys = headers.Select(c => c.Key);
var items = wRes.Headers.Where(c => !keys.Contains(c.Key));
headers.AddRange(items);
}
foreach (var item in headers)
{
if (item.Key == "Transfer-Encoding")
{
continue;
}
res.Headers.Add(item.Key, item.Value.ToArray());
}
//var content = await wRes.Content.ReadAsStringAsync();
var contB = await wRes.Content.ReadAsByteArrayAsync();
var content = Convert.ToBase64String(contB);
res.Response = content;
}
catch (Exception e)
{
var obj = new
{
request,
settingModel,
e
};
res.Status = (int)HttpStatusCode.InternalServerError;
if (Debugger.IsAttached)
{
res.Response = JsonConvert.SerializeObject(obj).Base64Encode();
}
}
return(res);
}
private void SetQueueName(QSettingModel setting)
{
qSetting = setting;
}
public BaseRPCReceiver(QSettingModel qSetting) : base(qSetting)
{
}
