public override void Process(Entity entity, Army army, GeoEntity geoEntity)
{
ArmyChangeEvent armyChangeEvent = new ArmyChangeEvent(army, geoEntity);
WsMessage wsMessage = WsMessageBuilder.CreateWsMessage("public", armyChangeEvent);
_jEventBus.Post(wsMessage);
}
public virtual WsMessage HelloWCF(WsMessage request)
{
// Build request object
HelloWCFDataContractSerializer reqDcs;
reqDcs = new HelloWCFDataContractSerializer("HelloWCF", "http://localhost/ServiceHelloWCF");
HelloWCF req;
req = ((HelloWCF)(reqDcs.ReadObject(request.Reader)));
request.Reader.Dispose();
request.Reader = null;
// Create response object
// Call service operation to process request and return response.
HelloWCFResponse resp;
resp = m_service.HelloWCF(req);
// Create response header
WsWsaHeader respHeader = new WsWsaHeader("http://localhost/ServiceHelloWCF/IServiceHelloWCF/HelloWCFResponse", request.Header.MessageID, m_version.AnonymousUri, null, null, null);
WsMessage response = new WsMessage(respHeader, resp, WsPrefix.Wsdp);
// Create response serializer
HelloWCFResponseDataContractSerializer respDcs;
respDcs = new HelloWCFResponseDataContractSerializer("HelloWCFResponse", "http://localhost/ServiceHelloWCF");
response.Serializer = respDcs;
return(response);
}
public virtual WsMessage CreateMeasurement(WsMessage request)
{
// Build request object
CreateMeasurementDataContractSerializer reqDcs;
reqDcs = new CreateMeasurementDataContractSerializer("CreateMeasurement", "http://tempuri.org/");
CreateMeasurement req;
req = ((CreateMeasurement)(reqDcs.ReadObject(request.Reader)));
request.Reader.Dispose();
request.Reader = null;
// Create response object
// Call service operation to process request and return response.
CreateMeasurementResponse resp;
resp = m_service.CreateMeasurement(req);
// Create response header
WsWsaHeader respHeader = new WsWsaHeader("http://tempuri.org/ISmartService/CreateMeasurementResponse", request.Header.MessageID, m_version.AnonymousUri, null, null, null);
WsMessage response = new WsMessage(respHeader, resp, WsPrefix.Wsdp);
// Create response serializer
CreateMeasurementResponseDataContractSerializer respDcs;
respDcs = new CreateMeasurementResponseDataContractSerializer("CreateMeasurementResponse", "http://tempuri.org/");
response.Serializer = respDcs;
return(response);
}
/// <summary>
/// Implements the IWsServiceEndpoint.ProcessRequest method.
/// Gets a service operation based on the action property sent in the soap header and calls
/// invoke on the service method.
/// </summary>
/// <param name="header">A WsWsaHeader containing the header proerties of a request.</param>
/// <param name="envelope">A WsXmlDocument containing the entire envelope of the message in a node tree.</param>
/// <returns>A byte array containing a soap response to the request.</returns>
WsMessage ProcessRequest(WsMessage request)
{
WsWsaHeader header = request.Header;
String action = header.Action;
// Display the action name.
System.Ext.Console.Write("Action: " + action);
// Look for a valid service Action
WsServiceOperation operation = m_serviceOperations[action];
if (operation != null)
{
System.Reflection.MethodInfo methodInfo = this.GetType().GetMethod(operation.MethodName);
if (methodInfo == null)
{
System.Ext.Console.Write("");
System.Ext.Console.Write("Operation method for action " + header.Action + " was not found");
System.Ext.Console.Write("");
throw new WsFaultException(header, WsFaultType.WsaDestinationUnreachable);
}
return((WsMessage)methodInfo.Invoke(this, new object[] { request }));
}
// If a valid Action is not found, fault
throw new WsFaultException(header, WsFaultType.WsaDestinationUnreachable, "To: " + header.To + " Action: " + action);
}
public virtual WsMessage SetData(WsMessage request)
{
// Build request object
SetDataDataContractSerializer reqDcs;
reqDcs = new SetDataDataContractSerializer("SetData", "http://tempuri.org/");
reqDcs.BodyParts = request.BodyParts;
SetData req;
req = ((SetData)(reqDcs.ReadObject(request.Reader)));
request.Reader.Dispose();
request.Reader = null;
// Create response object
// Call service operation to process request and return response.
SetDataResponse resp;
resp = m_service.SetData(req);
// Create response header
WsWsaHeader respHeader = new WsWsaHeader("http://tempuri.org/IDataAccessService/SetDataResponse", request.Header.MessageID, m_version.AnonymousUri, null, null, null);
WsMessage response = new WsMessage(respHeader, resp, WsPrefix.Wsdp);
// Create response serializer
SetDataResponseDataContractSerializer respDcs;
respDcs = new SetDataResponseDataContractSerializer("SetDataResponse", "http://tempuri.org/");
response.Serializer = respDcs;
// Indicate that message is Mtom encoded
response.BodyParts = new WsMtomBodyParts();
return(response);
}
public virtual WsMessage TwoWayAttachment(WsMessage request)
{
// Build request object
TwoWayAttachmentRequestDataContractSerializer reqDcs;
reqDcs = new TwoWayAttachmentRequestDataContractSerializer("TwoWayAttachmentRequest", "http://schemas.example.org/AttachmentService");
reqDcs.BodyParts = request.BodyParts;
TwoWayAttachmentRequest req;
req = ((TwoWayAttachmentRequest)(reqDcs.ReadObject(request.Reader)));
// Create response object
// Call service operation to process request and return response.
TwoWayAttachmentResponse resp;
resp = m_service.TwoWayAttachment(req);
// Create response header
WsWsaHeader respHeader = new WsWsaHeader("http://schemas.example.org/AttachmentService/TwoWayAttachmentResponse", request.Header.MessageID, m_version.AnonymousUri, null, null, null);
WsMessage response = new WsMessage(respHeader, resp, WsPrefix.Wsdp);
// Create response serializer
TwoWayAttachmentResponseDataContractSerializer respDcs;
respDcs = new TwoWayAttachmentResponseDataContractSerializer("TwoWayAttachmentResponse", "http://schemas.example.org/AttachmentService");
response.Serializer = respDcs;
// Indicate that message is Mtom encoded
response.BodyParts = new WsMtomBodyParts();
return(response);
}
private void BroadCastGame(GameDTO gameDTO)
{
WsMessage wsMessage = new WsMessage();
wsMessage.Action = "UpdateGame";
wsMessage.Content = gameDTO;
gameDTO.connectedPlayers[0].hero.mana = gameDTO.connectedPlayers[0].hero.maxMana;
gameDTO.connectedPlayers[1].hero.mana = gameDTO.connectedPlayers[1].hero.maxMana;
foreach (SocketClient client in Program.socketClients)
{
if (gameDTO.connectedPlayers[0] != null)
{
if (client.userDTO.username == gameDTO.connectedPlayers[0].username)
{
Program.socketServer.SendClientMessage(client.socket, JsonConvert.SerializeObject(gameDTO));
}
}
if (gameDTO.connectedPlayers[1] != null)
{
if (client.userDTO.username == gameDTO.connectedPlayers[1].username)
{
wsMessage.Content = SwapPlayers(gameDTO);
Program.socketServer.SendClientMessage(client.socket, JsonConvert.SerializeObject(gameDTO));
}
}
}
}
private void OnMessageReceived(WebSocketSession session, string value)
{
WsMessage message = Newtonsoft.Json.JsonConvert.DeserializeObject <WsMessage>(value);
// TO DO CRACIUN: live updating charts
if (message.type != "Alert")
{
if (cartesianChart1.InvokeRequired)
{
UpdateChartCb d = new UpdateChartCb(SetCartesianChart);
this.Invoke(d, new object[] { message });
}
else
{
SetCartesianChart(message);
}
}
else
{
MessageBox.Show("Don't panic!!!", "Earthquake", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
// TO DO: HANDLE ALERTS
// if(message.type == Alert)
}
public async Task Excute(WebSocketConnection connection, string requestString)
{
var message = new WsMessage();
try
{
var request = requestString.DeserializeJson <WsRequest>();
message.MsgType = WsMessageType.Result;
message.Id = request.Id;
message.Method = request.Method;
var session = _provider.GetService <WebSocketSession>();
session.Connection = connection;
session.Request = request;
var executor = _provider.GetService <WebSocketExecutor>();
var result = await executor.Excute(request);
if (result is WsError error)
{
message.MsgType = WsMessageType.Error;
message.Error = error;
}
else
{
message.Result = result;
}
}
catch (ArgumentException ex)
{
message.MsgType = WsMessageType.Error;
message.Error = new WsError()
{
Code = (int)ErrorCode.InvalidPara,
Message = ex.Message,
};
}
catch (WsException wsEx)
{
message.MsgType = WsMessageType.Error;
message.Error = new WsError()
{
Code = wsEx.Code,
Message = wsEx.Message,
};
}
catch (Exception e)
{
message.MsgType = WsMessageType.Error;
message.Error = new WsError()
{
Code = -1,
Message = e.ToString(),
};
}
finally
{
connection.PushMessage(message);
}
}
internal WsMessage ReceiveMessage(BindingContext ctx)
{
WsMessage msg = new WsMessage(new WsWsaHeader(), null, WsPrefix.None);
while (true)
{
try
{
if (!m_binding.Elements.ProcessInputMessage(ref msg, ctx))
{
msg = null;
}
// only need to loop if we received a bad request
break;
}
catch (Faults.WsFaultException ex)
{
WsMessage faultResp = Faults.WsFault.GenerateFaultResponse(ex, ctx.Version);
if (faultResp != null)
{
SendMessage(faultResp, ctx);
}
}
}
return(msg);
}
private async Task WaitForConnect(HttpContext context, WebSocket webSocket)
{
var buffer = new byte[1024 * 4];
WebSocketReceiveResult result = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);
Contract.Assert(!result.CloseStatus.HasValue);
try
{
string json = Encoding.UTF8.GetString(buffer, 0, result.Count);
WsMessage message = CatanProxy.Deserialize <WsMessage>(json);
if (message.MessageType != CatanWsMessageType.RegisterForGameNotifications)
{
throw new Exception($"Invalid Message sent: {message} - DataTypeName=CatanWsMessageType");
}
await GameController.Games.RegisterWebSocket(context, webSocket); // runs until the end
}
catch (Exception e)
{
await webSocket.SendAsync(new ArraySegment <byte>(Encoding.UTF8.GetBytes(e.ToString()), 0, result.Count), result.MessageType, result.EndOfMessage, CancellationToken.None);
}
await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
}
internal void SendMessage(WsMessage message, BindingContext ctx)
{
// Reset the binding properties as they were likely changed by the receive
ctx.BindingProperties = (ArrayList)m_context.BindingProperties.Clone();
m_binding.Elements.ProcessOutputMessage(ref message, ctx);
}
/// <summary>
/// Method used to send a soap request over http to a service endpoint.
/// </summary>
/// <param name="soapMessage">A byte array contining a soap request message.</param>
/// <param name="endpointAddress">A string containing the endpoint address of a service that will receive
/// the request. This must be a transport address in the format http://ip_address:port/service_address.</param>
/// <param name="isOneway">True = don't wait for response, false means wait for a response.</param>
/// <param name="isChuncked">If true true the message will be chunk encoded.</param>
/// <returns>
/// A DpwSoapResponse object containing a WsWsaHeader and a XmlReader or null if no response is received
/// or parsing fails.
/// </returns>
public DpwsSoapResponse SendRequest(byte[] soapMessage, string endpointAddress, bool isOneway, bool isChuncked)
{
System.Ext.Console.Write(new string(System.Text.UTF8Encoding.UTF8.GetChars(soapMessage)));
WsMessage response = SendRequest(soapMessage, endpointAddress, isOneway, isChuncked, null);
if (isOneway)
{
return(null);
}
XmlReader reader;
WsWsaHeader header;
try
{
reader = WsSoapMessageParser.ParseSoapMessage(response.Message, out header);
}
catch
{
System.Ext.Console.Write("ParseSoapMessage failed.");
return(null);
}
return(new DpwsSoapResponse(header, reader));
}
public virtual WsMessage AnyCheck(WsMessage request)
{
// Build request object
AnyCheckRequestDataContractSerializer reqDcs;
reqDcs = new AnyCheckRequestDataContractSerializer("AnyCheckRequest", "http://schemas.example.org/SimpleService");
AnyCheckRequest req;
req = ((AnyCheckRequest)(reqDcs.ReadObject(request.Reader)));
// Create response object
// Call service operation to process request and return response.
AnyCheckResponse resp;
resp = m_service.AnyCheck(req);
// Create response header
WsWsaHeader respHeader = new WsWsaHeader("http://schemas.example.org/SimpleService/AnyCheckResponse", request.Header.MessageID, m_version.AnonymousUri, null, null, null);
WsMessage response = new WsMessage(respHeader, resp, WsPrefix.Wsdp);
// Create response serializer
AnyCheckResponseDataContractSerializer respDcs;
respDcs = new AnyCheckResponseDataContractSerializer("AnyCheckResponse", "http://schemas.example.org/SimpleService");
response.Serializer = respDcs;
return(response);
}
// TwoWayRequest: Accept two integer values, return their sum
public WsMessage TwoWayRequest(WsMessage request)
{
WsWsaHeader header = request.Header;
XmlReader reader = request.Reader;
try
{
// Find beginning of request
reader.ReadStartElement("TwoWayRequest", SimpleServiceNamespaceUri);
// Find the values to be added
int X = Convert.ToInt32(reader.ReadElementString("X", SimpleServiceNamespaceUri));
int Y = Convert.ToInt32(reader.ReadElementString("Y", SimpleServiceNamespaceUri));
//Log.Comment("");
//Log.Comment("X = " + X.ToString() + " Y = " + Y.ToString());
//Log.Comment(X.ToString() + " + " + Y.ToString() + " = " + ((int)(X + Y)).ToString());
//Log.Comment("");
// Return the response
return(TwoWayResponse(header, X + Y));
}
catch (Exception e)
{
// Something went wrong
throw new WsFaultException(header, WsFaultType.XmlException, e.ToString());
}
}
public async Task Excute(WebSocketConnection connection, string requestString)
{
var message = new WsMessage();
try
{
var request = requestString.DeserializeJson <WsRequest>();
message.Type = WsMessageType.Result;
message.Id = request.Id;
message.Method = request.Method;
var session = _provider.GetService <WebSocketSession>();
session.Connection = connection;
session.Request = request;
var executor = _provider.GetService <WebSocketExecutor>();
var result = await executor.Excute(request);
message.Result = result;
}
catch (InvokerException invokerException)
{
message.Result = invokerException.Message;
}
catch (Exception e)
{
message.Type = WsMessageType.Error;
message.Result = e.ToString();
}
finally
{
connection.PushMessage(message);
}
}
/// <summary>
/// A wrapper method that implements the ProcessRequest interface used to control blocking of request.
/// The BlockingCall property is used by the stack to control single instance execution. Hello and Bye
/// are not blocked. Event messages from a device are blocked. This means it is up to a client developer
/// to insure long thread safety.
/// </summary>
/// <param name="header">A WsWsaHeader containing the header proerties of a request.</param>
/// <param name="envelope">A WsXmlDocument containing the entire envelope of the message in a node tree.</param>
/// <returns>A byte array containing a soap response to the request.</returns>
WsMessage IWsServiceEndpoint.ProcessRequest(WsMessage request)
{
//We always block
WsWsaHeader header = request.Header;
if (header.MessageID != null &&
m_messageCheck.IsDuplicate(header.MessageID, header.From != null ? header.From.Address.AbsoluteUri : ""))
{
return(null);
}
if (header.Action.IndexOf(m_version.DiscoveryNamespace) == 0)
{
String action = header.Action.Substring(m_version.DiscoveryNamespace.Length + 1);
switch (action)
{
case "Hello":
return(Hello(request.Header, request.Reader));
case "Bye":
return(Bye(request.Header, request.Reader));
}
}
System.Ext.Console.Write("Client discovery callback method for action " + header.Action + " was not found");
return(null);
}
private void HandleWorldJson(int planetId, string planetDisplayName, WsMessage message)
{
JObject payload;
try
{
payload = JObject.Parse(Encoding.UTF8.GetString(message.Buffer));
payload["world_id"] = planetId;
}
catch (Exception ex)
{
Log.Error(ex, "Error decoding World JSON message");
return;
}
var jsonString = payload.ToString(Formatting.Indented);
if (ProxyManagerConfig.Instance.SaveWorldJson)
{
var filename = $"{planetDisplayName}.json";
WriteExportFile(filename, jsonString);
}
if (ProxyManagerConfig.Instance.UploadWorldJson)
{
UploadJson(jsonString, "/ingest-ws-data/", planetDisplayName, "World");
}
}
// Implements the IWsServiceEndpoint.ProcessRequest method.
// Gets a service callback method based on the action property sent in a soap header and calls
// invoke on the callback method.
private WsMessage ProcessRequest(WsMessage request)
{
WsServiceOperation callback;
WsWsaHeader header = request.Header;
// Look for a client event sink callback action
if ((callback = m_eventCallbacks[header.Action]) != null)
{
System.Reflection.MethodInfo methodInfo = this.GetType().GetMethod(callback.MethodName);
if (methodInfo == null)
{
System.Ext.Console.Write("");
System.Ext.Console.Write("Client event callback method for action " + header.Action + " was not found");
System.Ext.Console.Write("");
// If a valid Action is not found, fault
throw new WsFaultException(header, WsFaultType.WsaDestinationUnreachable, "To: " + header.To + " Action: " + header.Action);
}
return((WsMessage)methodInfo.Invoke(this, new object[] { request }));
}
// If a valid Action is not found, fault
throw new WsFaultException(header, WsFaultType.WsaDestinationUnreachable, "To: " + header.To + " Action: " + header.Action);
}
/// <summary>
/// Method used to send an http Bye message to specified endpoint. Use for managed discovery.
/// </summary>
/// <param name="endpointAddress">A string containing the endpoint address of a listening client.</param>
public void DirectedBye(string endpointAddress, DpwsDiscoGreeting greeting, ProtocolVersion version)
{
WsMessage greetingsMessage = greeting.BuildByeMessage(endpointAddress, null, null);
Ws.Services.Transport.HTTP.WsHttpClient httpClient = new Ws.Services.Transport.HTTP.WsHttpClient(version);
httpClient.SendRequestOneWay(greetingsMessage, new Uri(endpointAddress));
}
public void SendGame(GameDTO game, string action)
{
WsMessage gameState = new WsMessage();
gameState.Content = game;
gameState.Action = action;
string data = JsonConvert.SerializeObject(gameState);
foreach (SocketClient client in Program.socketClients)
{
if (game.connectedPlayers[0] != null)
{
if (client.userDTO.username == game.connectedPlayers[0].username)
{
Program.socketServer.SendClientMessage(client.socket, data);
}
}
if (game.connectedPlayers[1] != null)
{
if (client.userDTO.username == game.connectedPlayers[1].username)
{
gameState.Content = SwapPlayers(game);
Program.socketServer.SendClientMessage(client.socket, data);
}
}
}
}
// Build ws-discovery bye message
internal WsMessage BuildByeMessage(string endpointAddress, WsWsaHeader header, XmlReader reader)
{
using (XmlMemoryWriter xmlWriter = XmlMemoryWriter.Create())
{
WsWsaHeader byeHeader = new WsWsaHeader(
m_version.DiscoveryNamespace + "/Bye", // Action
null, // RelatesTo
endpointAddress, // To
null, null, null); // ReplyTo, From, Any
WsMessage msg = new WsMessage(byeHeader, null, WsPrefix.Wsd, null,
new WsAppSequence(Device.AppSequence, Device.SequenceID, Device.MessageID));
WsSoapMessageWriter smw = new WsSoapMessageWriter(m_version);
smw.WriteSoapMessageStart(xmlWriter, msg);
// write body
xmlWriter.WriteStartElement(WsNamespacePrefix.Wsd, "Bye", null);
xmlWriter.WriteStartElement(WsNamespacePrefix.Wsa, "EndpointReference", null);
xmlWriter.WriteStartElement(WsNamespacePrefix.Wsa, "Address", null);
xmlWriter.WriteString(Device.EndpointAddress);
xmlWriter.WriteEndElement();
xmlWriter.WriteEndElement();
xmlWriter.WriteEndElement();
smw.WriteSoapMessageEnd(xmlWriter);
msg.Body = xmlWriter.ToArray();
// Return stream buffer
return(msg);
}
}
private WsMessage GetStatusResponse(WsWsaHeader header, long newDuration)
{
using (XmlMemoryWriter xmlWriter = XmlMemoryWriter.Create())
{
WsWsaHeader responseHeader = new WsWsaHeader(
WsWellKnownUri.WseNamespaceUri + "/RenewResponse", // Action
header.MessageID, // RelatesTo
header.ReplyTo.Address.AbsoluteUri, // To
null, null, null); // ReplyTo, From, Any
WsMessage msg = new WsMessage(responseHeader, null, WsPrefix.Wse,
null, new WsAppSequence(Device.AppSequence, Device.SequenceID, Device.MessageID)); // AppSequence
// write body
xmlWriter.WriteStartElement(WsNamespacePrefix.Wse, "Expires", null);
xmlWriter.WriteString(new WsDuration(newDuration).DurationString);
xmlWriter.WriteEndElement(); // End Expires
WsSoapMessageWriter smw = new WsSoapMessageWriter(m_version);
smw.WriteSoapMessageEnd(xmlWriter);
msg.Body = xmlWriter.ToArray();
return(msg);
}
}
public virtual TypeCheckResponse TypeCheck(TypeCheckRequest req)
{
// Create request header
String action;
action = "http://schemas.example.org/SimpleService/TypeCheck";
WsWsaHeader header;
header = new WsWsaHeader(action, null, EndpointAddress, m_version.AnonymousUri, null, null);
WsMessage request = new WsMessage(header, req, WsPrefix.None);
// Create request serializer
TypeCheckRequestDataContractSerializer reqDcs;
reqDcs = new TypeCheckRequestDataContractSerializer("TypeCheckRequest", "http://schemas.example.org/SimpleService");
request.Serializer = reqDcs;
request.Method = "TypeCheck";
// Send service request
m_requestChannel.Open();
WsMessage response = m_requestChannel.Request(request);
m_requestChannel.Close();
// Process response
TypeCheckResponseDataContractSerializer respDcs;
respDcs = new TypeCheckResponseDataContractSerializer("TypeCheckResponse", "http://schemas.example.org/SimpleService");
TypeCheckResponse resp;
resp = ((TypeCheckResponse)(respDcs.ReadObject(response.Reader)));
return(resp);
}
/// <summary>
/// send message (json format) to connection in queue
/// </summary>
/// <param name="message"></param>
public void PushMessage(WsMessage message)
{
if (message != null)
{
_pushMessagesQueue.Add(message);
}
}
public virtual void OneWayAttachment(OneWayAttachmentRequest req)
{
// Create request header
String action;
action = "http://schemas.example.org/AttachmentService/OneWayAttachment";
WsWsaHeader header;
header = new WsWsaHeader(action, null, EndpointAddress, m_version.AnonymousUri, null, null);
WsMessage request = new WsMessage(header, req, WsPrefix.None);
// Create request serializer
OneWayAttachmentRequestDataContractSerializer reqDcs;
reqDcs = new OneWayAttachmentRequestDataContractSerializer("OneWayAttachmentRequest", "http://schemas.example.org/AttachmentService");
request.Serializer = reqDcs;
request.Method = "OneWayAttachment";
// Indicate that this message will use Mtom encoding
request.BodyParts = new WsMtomBodyParts();
// Send service request
m_requestChannel.Open();
m_requestChannel.RequestOneWay(request);
m_requestChannel.Close();
}
public void SendMessage(WsMessage wsMessage)
{
wsMessage.From = "Server";
var send = JsonConvert.SerializeObject(wsMessage);
Server.MulticastText(send);
}
// OneWay: Accept an integer value
public WsMessage OneWay(WsMessage request)
{
try
{
WsWsaHeader header = request.Header;
XmlReader reader = request.Reader;
// Find beginning of request
reader.ReadStartElement("OneWay", SimpleServiceNamespaceUri);
// Find the integer value
int number = Convert.ToInt32(reader.ReadElementString("Param", SimpleServiceNamespaceUri));
//Log.Comment("");
//Log.Comment("Integer = " + number.ToString());
//Log.Comment("");
return(null); // Empty response
}
catch (Exception e)
{
// Something went wrong
throw new WsFaultException(request.Header, WsFaultType.XmlException, e.ToString());
}
}
public virtual WsMessage keepAlive(WsMessage request)
{
// Build request object
keepAliveDataContractSerializer reqDcs;
reqDcs = new keepAliveDataContractSerializer("keepAlive", "http://tempuri.org/");
keepAlive req;
req = ((keepAlive)(reqDcs.ReadObject(request.Reader)));
request.Reader.Dispose();
request.Reader = null;
// Create response object
// Call service operation to process request and return response.
keepAliveResponse resp;
resp = m_service.keepAlive(req);
// Create response header
WsWsaHeader respHeader = new WsWsaHeader("http://tempuri.org/IService1/keepAliveResponse", request.Header.MessageID, m_version.AnonymousUri, null, null, null);
WsMessage response = new WsMessage(respHeader, resp, WsPrefix.Wsdp);
// Create response serializer
keepAliveResponseDataContractSerializer respDcs;
respDcs = new keepAliveResponseDataContractSerializer("keepAliveResponse", "http://tempuri.org/");
response.Serializer = respDcs;
return(response);
}
public virtual HelloWCFResponse HelloWCF(HelloWCF req)
{
// Create request header
String action;
action = "http://localhost/ServiceHelloWCF/IServiceHelloWCF/HelloWCF";
WsWsaHeader header;
header = new WsWsaHeader(action, null, EndpointAddress, m_version.AnonymousUri, null, null);
WsMessage request = new WsMessage(header, req, WsPrefix.None);
// Create request serializer
HelloWCFDataContractSerializer reqDcs;
reqDcs = new HelloWCFDataContractSerializer("HelloWCF", "http://localhost/ServiceHelloWCF");
request.Serializer = reqDcs;
request.Method = "HelloWCF";
// Send service request
m_requestChannel.Open();
WsMessage response = m_requestChannel.Request(request);
m_requestChannel.Close();
// Process response
HelloWCFResponseDataContractSerializer respDcs;
respDcs = new HelloWCFResponseDataContractSerializer("HelloWCFResponse", "http://localhost/ServiceHelloWCF");
HelloWCFResponse resp;
resp = ((HelloWCFResponse)(respDcs.ReadObject(response.Reader)));
return(resp);
}
