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); }