/// <summary>
/// 截获从Client端发送的消息转发到目标终结点并获得返回值给Client端
/// </summary>
/// <param name="requestMessage"></param>
/// <returns></returns>
public Message ProcessMessage(Message requestMessage)
{
//Binding binding = null;
EndpointAddress endpointAddress = null;
GetServiceEndpoint(requestMessage, out endpointAddress);
IDuplexRouterCallback callback = OperationContext.Current.GetCallbackChannel <IDuplexRouterCallback>();
NetTcpBinding tbinding = new NetTcpBinding("netTcpExpenseService_ForSupplier");
using (DuplexChannelFactory <IRouterService> factory = new DuplexChannelFactory <IRouterService>(new InstanceContext(null, new DuplexRouterCallback(callback)), tbinding, endpointAddress))
{
factory.Endpoint.Behaviors.Add(new MustUnderstandBehavior(false));
IRouterService proxy = factory.CreateChannel();
using (proxy as IDisposable)
{
// 请求消息记录
IClientChannel clientChannel = proxy as IClientChannel;
//Console.WriteLine(String.Format("Request received at {0}, to {1}\r\n\tAction: {2}", DateTime.Now, clientChannel.RemoteAddress.Uri.AbsoluteUri, requestMessage.Headers.Action));
if (WcfServerManage.IsDebug)
{
hostwcfMsg(DateTime.Now, String.Format("路由请求消息发送： {0}", clientChannel.RemoteAddress.Uri.AbsoluteUri));
}
// 调用绑定的终结点的服务方法
Message responseMessage = proxy.ProcessMessage(requestMessage);
// 应答消息记录
//Console.WriteLine(String.Format("Reply received at {0}\r\n\tAction: {1}", DateTime.Now, responseMessage.Headers.Action));
//Console.WriteLine();
//hostwcfMsg(DateTime.Now, String.Format("应答消息： {0}", responseMessage.Headers.Action));
return(responseMessage);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="T:MessageHandlers.Handlers.ConnectionHandler"/> class.
/// </summary>
/// <param name="messageTypes">Message types.</param>
public ConnectionHandler(IStorageService storageService,
IRouterService routerService,
params string[] messageTypes)
{
this.routerService = routerService;
this.storageService = storageService;
this.messageTypes = messageTypes;
}
/// <summary>
/// 截获从Client端发送的消息转发到目标终结点并获得返回值给Client端
/// </summary>
/// <param name="requestMessage"></param>
/// <returns></returns>
public Message ProcessMessage(Message requestMessage)
{
try
{
begintime();
IRouterService proxy = null;
HeaderParameter para = HeaderOperater.GetHeaderValue(requestMessage);
if (RouterServerManage.routerDic.ContainsKey(para.routerid))
{
proxy = RouterServerManage.routerDic[para.routerid];
para.replyidentify = RouterServerManage.headParaDic[para.routerid].replyidentify;
}
else
{
//Binding binding = null;
EndpointAddress endpointAddress = null;
Uri touri = null;
para = RouterServerManage.AddClient(requestMessage, para, out endpointAddress, out touri);
requestMessage.Headers.To = touri;
IDuplexRouterCallback callback = OperationContext.Current.GetCallbackChannel <IDuplexRouterCallback>();
NetTcpBinding tbinding = new NetTcpBinding("NetTcpBinding_WCFHandlerService");
DuplexChannelFactory <IRouterService> factory = new DuplexChannelFactory <IRouterService>(new InstanceContext(new DuplexRouterCallback(callback)), tbinding, endpointAddress);
proxy = factory.CreateChannel();
//缓存会话
RouterServerManage.routerDic.Add(para.routerid, proxy);
RouterServerManage.headParaDic.Add(para.routerid, para);
}
Message responseMessage = null;
HeaderOperater.AddMessageHeader(requestMessage, para);//增加自定义消息头
responseMessage = proxy.ProcessMessage(requestMessage);
if (para.cmd == "Quit")
{
//关闭连接释放缓存会话
RouterServerManage.RemoveClient(para);
}
double outtime = endtime();
// 请求消息记录
if (WcfServerManage.IsDebug)
{
RouterServerManage.hostwcfMsg(Color.Black, DateTime.Now, String.Format("路由请求消息发送(耗时[" + outtime + "])： {0}", requestMessage.Headers.Action));
}
return(responseMessage);
}
catch (Exception e)
{
return(Message.CreateMessage(requestMessage.Version, FaultCode.CreateReceiverFaultCode("error", RouterServerManage.ns), e.Message, requestMessage.Headers.Action));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="T:MessageHandlers.Handlers.ConnectionHandler"/> class.
/// </summary>
public ConnectionHandler(IStorageService storageService,
IRouterService routerService)
: this(storageService, routerService,
SovrinMessages.CONNECTION_OFFER,
SovrinMessages.CONNECTION_REQUEST,
SovrinMessages.CONNECTION_RESPONSE,
SovrinMessages.CONNECTION_ACKONOWLEDGEMENT,
StreetcredMessages.SEND_NYM,
StreetcredMessages.CREATE_CONNECTION_OFFER)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="T:Service.Controllers.AgentController"/> class.
/// </summary>
/// <param name="initializationService">Initialization service.</param>
public AgentController(InitializationService initializationService, IRouterService routerService, IStorageService storageService)
{
this.storageService = storageService;
this.Handlers = new IHandler[]
{
new ConnectionHandler(storageService, routerService),
new MessagesHandler(storageService)
};
this.initializationService = initializationService;
this.routerService = routerService;
}
public DefaultConnectionService(
IWalletRecordService recordService,
IRouterService routerService,
IProvisioningService provisioningService,
IMessageSerializer messageSerializer,
ILogger <DefaultConnectionService> logger)
{
RouterService = routerService;
ProvisioningService = provisioningService;
MessageSerializer = messageSerializer;
Logger = logger;
RecordService = recordService;
}
public static RouteWorkflowTask Go(
RouteRequest routeRequest,
IRouteEntryRegistry routeEntryRegistry,
IRouteAuthorizationManager routeAuthorizationManager,
IRouterService routerService,
ILogger logger)
{
var workflow = new RouteWorkflowTask(routeRequest, routeEntryRegistry, routeAuthorizationManager,
routerService,
logger);
workflow.RouteResult = workflow.GoAsync();
return(workflow);
}
public DefaultProofService(
IConnectionService connectionService,
IRouterService routerService,
IMessageSerializer messageSerializer,
IWalletRecordService recordService,
IProvisioningService provisioningService,
ILedgerService ledgerService,
ITailsService tailsService,
ILogger <DefaultProofService> logger)
{
TailsService = tailsService;
ConnectionService = connectionService;
RouterService = routerService;
MessageSerializer = messageSerializer;
RecordService = recordService;
ProvisioningService = provisioningService;
LedgerService = ledgerService;
Logger = logger;
}
public Message ProcessMessage(Message requestMessage)
{
Binding binding = null;
EndpointAddress endpointAddress = null;
GetServiceEndpoint(requestMessage, out binding, out endpointAddress);
using (ChannelFactory <IRouterService> factory = new ChannelFactory <IRouterService>(binding, endpointAddress))
{
OperationContext context = OperationContext.Current;
MessageProperties prop = context.IncomingMessageProperties;
RemoteEndpointMessageProperty endpoint = prop[RemoteEndpointMessageProperty.Name] as RemoteEndpointMessageProperty;
string src_ip = endpoint.Address;
int src_port = endpoint.Port;
factory.Endpoint.Behaviors.Add(new MustUnderstandBehavior(false));
IRouterService proxy = factory.CreateChannel();
using (proxy as IDisposable)
{
// log request message
IClientChannel clientChannel = proxy as IClientChannel;
var threadId = Thread.CurrentThread.ManagedThreadId;
string message = String.Format("Thread id {3},Source Ip:{4}: Request received at {0}, to {1}\r\tAction: {2}.", DateTime.Now, clientChannel.RemoteAddress.Uri.AbsoluteUri, requestMessage.Headers.Action, threadId, string.Format("{0}:{1}", src_ip, src_port));
Console.WriteLine(message);
LogManager.GetLogger().Info(message);
// invoke service
Message responseMessage = proxy.ProcessMessage(requestMessage);
// log response message
message = String.Format("Thread id {2},Source Ip:{3}: Reply received at {0}\r\tAction: {1}.", DateTime.Now, responseMessage.Headers.Action, threadId, string.Format("{0}:{1}", src_ip, src_port));
Console.WriteLine(message);
LogManager.GetLogger().Info(message);
Console.WriteLine();
return(responseMessage);
}
}
}
internal RouteWorkflowTask(
RouteRequest routeRequest,
IRouteEntryRegistry routeEntryRegistry,
IRouteAuthorizationManager routeAuthorizationManager,
IRouterService routerService,
ILogger logger)
{
_routeRequest = routeRequest;
_routeEntryRegistry = routeEntryRegistry;
_routeAuthorizationManager = routeAuthorizationManager;
_routerService = routerService;
_logger = logger
.ForContext(SerilogConstants.Serilog_SourceContext_Name, nameof(RouteWorkflowTask))
.ForContext("Uri", Uri)
.ForContext("ViewportName", ViewportOptions.ToString())
.ForContext("InitData", InitData)
.ForContext("RouterServiceId", _routerService.RouterServiceId)
.ForContext("RoutingWorkflowId", RoutingWorkflowId);
}
public DefaultCredentialService(
IRouterService routerService,
ILedgerService ledgerService,
IConnectionService connectionService,
IWalletRecordService recordService,
IMessageSerializer messageSerializer,
ISchemaService schemaService,
ITailsService tailsService,
IProvisioningService provisioningService,
ILogger <DefaultCredentialService> logger)
{
RouterService = routerService;
LedgerService = ledgerService;
ConnectionService = connectionService;
RecordService = recordService;
MessageSerializer = messageSerializer;
SchemaService = schemaService;
TailsService = tailsService;
ProvisioningService = provisioningService;
Logger = logger;
}
public Message ProcessMessage(Message requestMessage)
{
RegistrationList.Add("http://www.thatindigogirl.com/samples/2008/01/IServiceA", "ServiceA"); // services registration
RegistrationList.Add("http://www.thatindigogirl.com/samples/2008/01/IServiceB", "ServiceB");
/*Uri httpBase = new Uri(string.Format("http://localhost:{0}",FindFreePort()));
* Uri tcpBase = new Uri(string.Format("net.tcp://localhost:{0}",FindFreePort()));
* Uri netPipeBase = new Uri(string.Format("net.pipe://localhost/{0}",Guid.NewGuid().ToString()));
*
* ServiceHost host = new ServiceHost(typeof(ServiceA), httpBase, tcpBase, netPipeBase);*/
//header
string contractNamespace = requestMessage.Headers.Action.Substring(0, requestMessage.Headers.Action.LastIndexOf("/"));
string configurationName = RouterService.RegistrationList[contractNamespace];
var contractNamespaceHeaders = requestMessage.Headers.GetHeader <string>("Route", "http://www.thatindigogirl.com/samples/2008/01");
//body
//После прочтения сообщение невозможно перенаправить службам приложений,
//поскольку сообщение может быть только один раз прочитано, записано или скопировано.
MessageBuffer messageBuffer = requestMessage.CreateBufferedCopy(int.MaxValue);
Message messageCopy = messageBuffer.CreateMessage(); // create new instance of message base on buffered copy
XmlDictionaryReader bodyReader = messageCopy.GetReaderAtBodyContents();
XmlDocument doc = new XmlDocument();
doc.Load(bodyReader);
XmlNodeList elements = doc.GetElementsByTagName("LicenseKey");
string licenseKey = elements[0].InnerText;
using (var factory = new ChannelFactory <IRouterService>(configurationName))
{
factory.Endpoint.Behaviors.Add(new MustUnderstandBehavior(false)); // solve problem with response messages contains security headers
using (IRouterService proxy = factory.CreateChannel())
{
return(proxy.ProcessMessage(requestMessage));
}
}
}
public RoutersController(IRouterService routerService)
{
this.RouterService = routerService;
}
public RouterIntegratorProvController(IRouterService routerService, IMapperService mapperService, ILogger <RouterIntegratorProvController> logger)
{
_routerService = routerService;
_mapperService = mapperService;
_logger = logger;
}
public UtilityService(IConfiguration configuration, IRouterService routerService)
{
_configuration = configuration;
_routerService = routerService;
}
public TransactionService(IConfiguration configuration, IRouterService routerService)
{
_configuration = configuration;
_routerService = routerService;
}
public SoftBeckhoffController(ILogger <SoftBeckhoffController> logger, IPlcService plcService, IRouterService routerService)
{
this.logger = logger;
this.plcService = plcService;
this.routerService = routerService;
}
