public ITcpFrame PerformService(ILogger logger, IAppDocument iAppDocument)
{
AppDocument appDocument;
appDocument = ( AppDocument )iAppDocument;
MainForm mainForm = appDocument.MainForm;
// Start the browser.
MainForm.StartBrowserFormDelegate startBrowserFormDelegate;
startBrowserFormDelegate = new MainForm.StartBrowserFormDelegate(mainForm.StartBrowserForm);
BrowserForm browserForm = ( BrowserForm )mainForm.Invoke(startBrowserFormDelegate);
// Decode the request and generate a response.
ITcpFrame responseFrame = BuildResponse(browserForm);
// Stop the browser.
MainForm.StopBrowserFormDelegate stopBrowserFormDelegate;
stopBrowserFormDelegate = new MainForm.StopBrowserFormDelegate(mainForm.StopBrowserForm);
object[] args = new object[1];
args[0] = browserForm;
bool isRemoved = ( bool )mainForm.Invoke(stopBrowserFormDelegate, args);
// Return the framed results.
return(responseFrame);
}
static public async Task <int> SendFrame(ITcpFrame tcpFrame, BufferedStream bufferedStream, ILogger logger)
{
int count;
int offset;
string methodName = "SendFrame";
int sendFrameSize = tcpFrame.FramePacket.Length;
byte[] sendFrameBytes = tcpFrame.FramePacket;
// Encode the packet length into a byte array.
byte[] sendLengthBytes = BitConverter.GetBytes(sendFrameSize);
// Send the packet length to the server.
offset = 0;
count = sendLengthBytes.Length;
await bufferedStream.WriteAsync(sendLengthBytes, offset, count);
logger.WriteEntry(methodName + " sent frame length " + sendFrameSize.ToString());
if (sendFrameSize > 0)
{
// Send the request frame.
offset = 0;
count = sendFrameSize;
await bufferedStream.WriteAsync(sendFrameBytes, offset, count);
logger.WriteEntry(methodName + " sent packet to server. ");
}
return(sendFrameSize);
}
public async Task <IActionResult> TestSendReceive([FromBody] XmlPageRequestBody xmlPageRequestBody)
{
ILogger logger = new ConsoleLogger();
JsonResult jsonResult;
RequestResponseFrame responseFrame;
object jsonObject;
string methodName = "TestSendReceive";
logger.WriteEntry(methodName + " entry.");
if (ModelState.IsValid)
{
logger.WriteEntry(methodName + " ModelState is valid.");
string receiveUrl = xmlPageRequestBody.ReceiveUrl;
string receiveSearch = xmlPageRequestBody.ReceiveSearch;
GeneralClassLibrary.XmlPageRequestFrame xmlPageRequestFrame = new XmlPageRequestFrame(xmlPageRequestBody);
// Transform the API request to an ITcpFrame.
byte[] sendFrameBytes = xmlPageRequestFrame.ToByteArray();
RequestResponseFrame requestFrame = new RequestResponseFrame(sendFrameBytes);
// Connect to the server and obtain a network stream.
BufferedStream bufferedStream = await SendReceiveReply.ConnectToServer(RemoteHostName, RemotePortNumber, SizeStreamBuffer, logger);
// Send and receive data via the stream.
responseFrame = await SendReceiveReply.RequestReceiveResponse(bufferedStream, requestFrame, logger);
ITcpFrame tcpFrame = responseFrame;
byte[] replyFrameBytes = tcpFrame.FramePacket;
IpcFrameBase ipcFrameBase = ( IpcFrameBase )IpcFrameBase.FromByteArray(replyFrameBytes);
// Transform the ITcpFrame to an API response.
logger.WriteEntry(methodName + " building the JSON result.");
XmlPageReplyFrame xmlPageReplyFrame = ( XmlPageReplyFrame )ipcFrameBase;
jsonObject = new
{
textArray = xmlPageReplyFrame.ResultList,
isSuccess = true
};
}
else
{
logger.WriteEntry(methodName + " ModelState is not valid!");
jsonObject = new
{
textArray = new List <string>(),
isSuccess = false
};
}
logger.WriteEntry(methodName + " exit.");
jsonResult = new JsonResult(jsonObject);
return(jsonResult);
}
// Server IPC Cycle.
// Receive a request. Service the request. Reply with the result.
static public async Task <int> ReceiveServiceReply(BufferedStream bufferedStream, IServiceRequest serviceRequest, ILogger logger, IAppDocument appDocument)
{
int numberSent;
// Receive the request from the client.
ITcpFrame requestFrame = await ReceiveFrame(bufferedStream, logger);
// Identify and create the specific service to be performed.
IPerformService performService = serviceRequest.CreateService(requestFrame, logger);
// Perform the specific service and provide a response.
ITcpFrame responseFrame = performService.PerformService(logger, appDocument);
// Reply the response to the client.
numberSent = await SendFrame(responseFrame, bufferedStream, logger);
return(numberSent);
}
public IPerformService CreateService(ITcpFrame requestFrame, ILogger logger)
{
IPerformService performService;
IpcFrameBase ipcFrameBase = ( IpcFrameBase )IpcFrameBase.ByteArrayToObject(requestFrame.FramePacket);
switch (ipcFrameBase.ServiceActionEnum)
{
case ServiceActionEnum.XmlPageRequestServiceAction:
XmlPageRequestFrame xmlPageRequestFrame = ( XmlPageRequestFrame )ipcFrameBase;
XmlPageService xmlPageService = new XmlPageService(xmlPageRequestFrame);
performService = xmlPageService;
break;
case ServiceActionEnum.SizeServiceActionEnum:
default:
performService = null;
break;
}
return(performService);
}
// Client IPC Cycle.
// Send a request. Receive the response.
static public async Task <RequestResponseFrame> RequestReceiveResponse(BufferedStream bufferedStream, ITcpFrame sendTcpFrame, ILogger logger)
{
// Send the request to the server.
await SendFrame(sendTcpFrame, bufferedStream, logger);
// Receive the response from the server.
ITcpFrame tcpFrame;
tcpFrame = await ReceiveFrame(bufferedStream, logger);
// The response is ready to be processed.
RequestResponseFrame responseFrame = new RequestResponseFrame(tcpFrame.FramePacket);
return(responseFrame);
}
