/// <summary>
/// <remarks> wehat is mandatory and what is not?</remarks>
/// </summary>
/// <param name="data"></param>
/// <param name="em"></param>
/// <returns></returns>
public static ResponseData Deserialize( Hashtable data, byte[] body, ref string em)
{
ResponseData response = new ResponseData() { Data = data, Body = RMQBus.GetBodyString(body) };
try
{
RequestData.ErrorCodeEnum code;
Enum.TryParse<RequestData.ErrorCodeEnum> ( (string)data["error_code"], out code );
response.ErrorCode = code;
}
catch{}
try
{
response.Value = (int)data["value"];
}
catch{}
try
{
response.ErrorMessage = (string)data["error_message"];
}
catch { }
try
{
response.IsError = (bool)data["is_error"];
}
catch { }
return response;
}
public static RequestData Create(BasicReturnEventArgs args )
{
Hashtable headers = ConvertHeaders(args.BasicProperties.Headers);
var responseData = new ResponseData()
{
ErrorCode = (RequestData.ErrorCodeEnum)args.ReplyCode,
ErrorMessage = args.ReplyText
};
var requestData = new RequestData()
{
Body = Encoding.UTF8.GetString(args.Body),
SourceAddress = args.BasicProperties.AppId,
CorrelationId = args.BasicProperties.CorrelationId,
Op = (string)headers["op"],
Data = headers,
DestAddress = args.RoutingKey,
Response = responseData
};
return requestData;
}
/// <summary>
/// Send a message from one entity to another either over internal or external service bus.
/// Dispatch message asynchronously.
/// Represents fire&forget or RPC response.
/// </summary>
/// <param name="destAddress"></param>
/// <param name="destAddress"></param>
/// <param name="messageContent"></param>
/// <returns></returns>
public static void SendMessage( string sourceAddress, string destAddress, string op, string correlationId, ResponseData response )
{
RequestData requestData = requestData = new RequestData ( null )
{
Op = op
,
SourceAddress = sourceAddress
,
CorrelationId = correlationId
,
Response = response
,
DestAddress = destAddress
};
//address has to match registered comm object in order to send this message out. In other words an entity can be addressable locally and globally.
RMQServiceBusInterface busProc = (RMQServiceBusInterface)RMQBus.GetClient(sourceAddress);
//try to get sender's busprocess to use it's channels
if (busProc == null)
{
Tracer.TraceEvent ( TraceEventType.Error, 0, "[{0}] no global process visibility, no local destination found {1}, message dropped {2}", sourceAddress, destAddress, requestData );
return;
}
busProc.SendMessageImpl ( requestData );
}
/// <summary>
/// Raised when there is an error, can be service bus sepcific RequestData.ErrorCodeEnum.BusSpecificError.
/// Can be used to handle 321 UNROUTABLE when the second party does not exist (queue/topic/address does not exist)
/// </summary>
/// <param name="responseData"></param>
/// <para>On connect is invoked in the driver's thread.</para>
public virtual void OnPreError(ResponseData responseData)
{
ThreadPool.QueueUserWorkItem((r) =>
{
try
{
OnError(responseData);
}
catch (Exception ex)
{
throw;
}
});
}
/// <summary>
///
/// </summary>
/// <param name="responseData"></param>
protected virtual void OnError(ResponseData responseData)
{
}
public void SendMessage(string address, string op, string body, Hashtable data)
{
var responseData = new ResponseData()
{
Data = data,
Body = body,
};
Bus.SendMessage(this.Address, address, op, null, responseData);
}
public void SendMessage(string address, string op, string body)
{
var responseData = new ResponseData()
{
Body = body
};
this.SendMessage(address, op, body, null);
}
public void SendMessage(string address, string op, Hashtable data,string errorMessage)
{
var responseData = new ResponseData()
{
Data = data,
ErrorMessage = errorMessage
};
this.SendMessage(address, op, null, data);
}
public static ResponseData Error( string message )
{
ResponseData response = new ResponseData ();
response.ErrorMessage = message;
response.IsError = true;
return response;
}
public static ResponseData Error( RequestData.ErrorCodeEnum code,string message)
{
ResponseData response = new ResponseData ();
response.ErrorCode = code;
response.ErrorMessage = message;
response.IsError = true;
return response;
}
public static ResponseData Response( int value )
{
ResponseData response = new ResponseData ();
response.Value = value;
return response;
}
public static ResponseData ProcessDisposed(string address, string message = "process disposed")
{
ResponseData response = new ResponseData();
response.ErrorCode = RequestData.ErrorCodeEnum.ProcessDisposed;
response.ErrorMessage = message;
response.Body = address;
return response;
}
public static ResponseData FromBasicReturn(BasicReturnEventArgs args)
{
ResponseData response = new ResponseData();
response.DestinationAddress = args.RoutingKey;
response.Exchange = args.Exchange;
response.Value = args.ReplyCode;
response.ErrorCode = RequestData.ErrorCodeEnum.BusSpecificError;
response.ErrorMessage = args.ReplyText;
response.Data = RMQBus.ConvertHeaders(args.BasicProperties.Headers);
response.Body = RMQBus.GetBodyString(args.Body);
response.CorrelationId = args.BasicProperties.CorrelationId;
return response;
}
/// <summary>
///
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public static ResponseData FlowControlBufferOk(string message = "Carry on!")
{
ResponseData response = new ResponseData();
response.ErrorCode = RequestData.ErrorCodeEnum.FlowControl_BufferOk;
response.ErrorMessage = message;
return response;
}
/// <summary>
///
/// </summary>
/// <param name="message"></param>
/// <param name="address">last processed session</param>
/// <returns></returns>
public static ResponseData FlowControlBufferFull(string address,string message="Slow down!")
{
ResponseData response = new ResponseData();
response.ErrorCode = RequestData.ErrorCodeEnum.FlowControl_BufferFull;
response.ErrorMessage = message;
response.Body = address;
return response;
}
