public void Log(string format, params object[] arguments)
{
var message = _messageCreator.CreateMessage(
null, _callingStackFrameGetter.GetCallingStackFrame(1), Level.Debug, format, arguments);
var text = _messageTextFormatter.GetMessageAsText(message);
File.AppendAllText(_filePath, text);
}
public void Debug(string format, params object[] arguments)
{
if (!DebugEnabled)
{
return;
}
var message = _messageCreator.CreateMessage(
null, _callingStackFrameGetter.GetCallingStackFrame(1), Level.Debug, format, arguments);
_messagesDequeuer.WriteMessage(message);
}
public async Task ProduceAsync(string topic, object body)
{
try
{
var message = _messageCreator.CreateMessage(body);
var result = await _kafkaProducer.ProduceAsync(topic, message);
_logger.LogDebug("Delivered '{0}' to '{1}'", result.Value, result.TopicPartitionOffset);
}
catch (Exception ex)
{
_logger.LogError(ex, nameof(ProduceAsync));
throw ex;
}
}
/// <summary>
/// Send message to server
/// </summary>
/// <param name="queue"></param>
/// <param name="label"></param>
/// <param name="appSpecific"></param>
private void SendMessage(MessageQueue queue, byte[] buf, string label, int appSpecific)
{
var message = _messageCreator.CreateMessage(label, appSpecific, buf);
queue.Send(message);
message.Dispose();
}
public static T CreateMessage <T>(this IMessageCreator creator, Action <T> initialize) where T : class, IMessage
{
var message = creator.CreateMessage <T>();
initialize(message);
return(message);
}
protected virtual void DoSend(IClientSession channel, string exchange, string routingKey, IMessageCreator messageCreator,
MessageCreatorDelegate messageCreatorDelegate)
{
AssertUtils.IsTrue((messageCreator == null && messageCreatorDelegate != null) ||
(messageCreator != null && messageCreatorDelegate == null), "Must provide a MessageCreatorDelegate or IMessageCreator instance.");
Message message;
if (messageCreator != null)
{
message = messageCreator.CreateMessage();
}
else
{
message = messageCreatorDelegate();
}
if (exchange == null)
{
// try to send to default exchange
exchange = this.exchange;
}
if (routingKey == null)
{
// try to send to default routing key
routingKey = this.routingKey;
}
/* org.apache.qpid.client.IMessage message = new org.apache.qpid.client.Message();
* message.ClearData();
* message.AppendData(Encoding.UTF8.GetBytes("That's all, folks!"));
* session.MessageTransfer("amq.direct", "routing_key", message);
* session.Sync();
*
*/
org.apache.qpid.client.IMessage qpidMessage = new org.apache.qpid.client.Message();
qpidMessage.AppendData(message.Body);
qpidMessage.DeliveryProperties = QpidUtils.ExtractDeliveryProperties(message);
qpidMessage.DeliveryProperties.SetRoutingKey(routingKey);
qpidMessage.DeliveryProperties.SetExchange(exchange);
qpidMessage.DeliveryProperties.SetImmediate(this.immediatePublish);
//TODO where to set mandetoryPublish?
channel.MessageTransfer(exchange, routingKey, qpidMessage);
channel.Sync();
// TODO: should we be able to do (via wrapper) something like:
// channel.getTransacted()?
if (ChannelTransacted && ChannelLocallyTransacted(channel))
{
// Transacted channel created by this template -> commit.
QpidUtils.CommitIfNecessary(channel);
}
}
private Task <HttpResponseMessage> SendHttpMessage(
IMessageCreator messageCreator,
string endpointUrl,
HttpMethod method,
HttpContent content)
{
var message = messageCreator.CreateMessage(method, endpointUrl, content);
return(_httpClient.SendAsync(message));
}
public async Task <HttpResponseMessage> SendAsync(IMessageCreator messageCreator, string endpointUrl, HttpMethod method, HttpContent content = null, Dictionary <string, string> headers = null)
{
var message = messageCreator.CreateMessage(method, endpointUrl, content);
_requestBody = await message.Content.ReadAsStringAsync();
return(new HttpResponseMessage(HttpStatusCode.Accepted)
{
Content = new StringContent(_requestBody)
});
}
private Task <HttpResponseMessage> SendHttpMessage(
IMessageCreator messageCreator,
string endpointUrl,
HttpMethod method,
HttpContent content,
Dictionary <string, string> headers)
{
HttpRequestMessage message = messageCreator.CreateMessage(method, endpointUrl, content, headers);
return(_httpClient.SendAsync(message));
}
public void CreateMessage_AddCorrectSDKTreackingHeader()
{
var assembly = typeof(ManagementHttpClient).Assembly;
var fileVersionInfo = FileVersionInfo.GetVersionInfo(assembly.Location);
var sdkVersion = fileVersionInfo.ProductVersion;
var sdkPackageId = assembly.GetName().Name;
var msg = messageCreator.CreateMessage(HttpMethod.Post, string.Empty);
msg.Headers.TryGetValues("X-KC-SDKID", out var headerContent);
Assert.True(msg.Headers.Contains("X-KC-SDKID"));
Assert.Contains($"nuget.org;{sdkPackageId};{sdkVersion}", headerContent);
}
/// <summary>
/// Process single message. When we shouldn't split a byte array for chunks
/// </summary>
/// <param name="fullPath"></param>
public bool SendFile(string path)
{
using (var serverQueue = new MessageQueue(_options.MessageQueueServerName, QueueAccessMode.Send)) {
var fileStream = new FileStream(path, FileMode.Open);
try
{
var message = _messageCreator.CreateMessage(Path.GetFileName(path), AppSpecific, new byte[0]);
message.BodyStream = fileStream;
Send(serverQueue, message);
message.Dispose();
} catch (Exception e) {
throw new InvalidOperationException(e.Message);
} finally {
fileStream.Close();
}
}
return(true);
}
public async Task <HttpResponseMessage> SendAsync(
IMessageCreator messageCreator,
string endpointUrl,
HttpMethod method,
HttpContent content = null,
Dictionary <string, string> headers = null)
{
var message = messageCreator.CreateMessage(method, endpointUrl, content, headers);
var isFirst = _firstRequest;
_firstRequest = false;
var serializationSettings = new JsonSerializerSettings {
Formatting = Formatting.Indented
};
var serializedRequest = MakeAgnostic(JsonConvert.SerializeObject(message, serializationSettings));
var serializedRequestContent = await SerializeContent(message.Content);
var hashContent = $"{message.Method} {serializedRequest} {UnifySerializedRequestContent(serializedRequestContent)}";
var folderPath = GetMockFileFolder(message, hashContent);
if (_saveToFileSystem)
{
if (!Directory.Exists(folderPath))
{
Directory.CreateDirectory(folderPath);
}
else if (isFirst)
{
// Cleanup previously recorded data at first request to avoid data overlap upon change
Directory.Delete(folderPath, true);
}
var response = await _nativeClient.SendAsync(messageCreator, endpointUrl, method, content, headers);
File.WriteAllText(Path.Combine(folderPath, "request.json"), serializedRequest);
File.WriteAllText(Path.Combine(folderPath, "request_content.json"), serializedRequestContent);
var serializedResponse = MakeAgnostic(JsonConvert.SerializeObject(response, serializationSettings));
var serializedResponseContent = await SerializeContent(response.Content);
File.WriteAllText(Path.Combine(folderPath, "response.json"), serializedResponse);
File.WriteAllText(Path.Combine(folderPath, "response_content.json"), serializedResponseContent);
return(response);
}
else
{
// Expected request is validated through the presence of the recorded files
Assert.True(
Directory.Exists(folderPath),
$"Cannot find expected data folder {folderPath} for {message.Method} request to {message.RequestUri}. " + Environment.NewLine +
$"Either the request properties or content seem to differ from the expected recorded state." + Environment.NewLine +
$"Request:" + Environment.NewLine +
serializedRequest + Environment.NewLine +
$"Request content:" + Environment.NewLine +
serializedRequestContent
);
var serializedResponse = ApplyData(File.ReadAllText(Path.Combine(folderPath, "response.json")));
var serializedResponseContent = File.ReadAllText(Path.Combine(folderPath, "response_content.json"));
var deserializationSettings = new JsonSerializerSettings
{
ContractResolver = new IgnoreHttpContentContractResolver()
};
var response = JsonConvert.DeserializeObject <HttpResponseMessage>(serializedResponse, deserializationSettings);
response.Content = new StringContent(serializedResponseContent);
return(response);
}
}
/// <summary> Send the given EMS message.</summary>
/// <param name="session">the EMS Session to operate on
/// </param>
/// <param name="destination">the EMS Destination to send to
/// </param>
/// <param name="messageCreator">callback to create a EMS Message
/// </param>
/// <param name="messageCreatorDelegate">delegate callback to create a EMS Message
/// </param>
/// <exception cref="EMSException">If there is any problem accessing the EMS API</exception>
protected internal virtual void DoSend(ISession session, Destination destination, IMessageCreator messageCreator,
MessageCreatorDelegate messageCreatorDelegate)
{
IMessageProducer producer = CreateProducer(session, destination);
try
{
Message message;
if (messageCreator != null)
{
message = messageCreator.CreateMessage(session) ;
}
else {
message = messageCreatorDelegate(session);
}
if (logger.IsDebugEnabled)
{
logger.Debug("Sending created message [" + message + "]");
}
DoSend(producer, message);
// Check commit, avoid commit call is Session transaction is externally coordinated.
if (session.Transacted && IsSessionLocallyTransacted(session))
{
// Transacted session created by this template -> commit.
EmsUtils.CommitIfNecessary(session);
}
}
finally
{
EmsUtils.CloseMessageProducer(producer);
}
}
public static TMessage CreateMessage <TMessage>(this IMessageCreator creator) where TMessage : class, IMessage
{
var message = (TMessage)creator.CreateMessage(typeof(TMessage));
return(message);
}
