public EventSender(Device device, SimulatorConfiguration config, Func<object,byte[]> serializer)
{
_serializer = serializer;
var connectionString = ServiceBusConnectionStringBuilder.CreateUsingSharedAccessSignature(
device.Endpoint, device.EventHubName, device.Id, device.Token);
_eventHubSender = EventHubSender.CreateFromConnectionString(connectionString);
}
public static void SendData(TextWriter log)
{
_log = log;
var commercialVehicleRegistration = AzureResourcesCreator.CreateBlob();
AzureResourcesCreator.CreateAzureCosmosDb();
var eventHubSender = new EventHubSender();
try
{
// generate data
var generator = TollDataGenerator.Generator(commercialVehicleRegistration);
_timerInterval = TimeSpan.FromSeconds(Convert.ToDouble(CloudConfiguration.TimerInterval));
TimerCallback timerCallback = state =>
{
var startTime = DateTime.UtcNow;
generator.Next(startTime, _timerInterval, 5);
foreach (var tollEvent in generator.GetEvents(startTime))
{
eventHubSender.SendData(tollEvent);
++_eventCount;
}
_timer.Change((int)_timerInterval.TotalMilliseconds, Timeout.Infinite);
};
Timer timer = new Timer(Callback, null, TimeSpan.FromSeconds(60), TimeSpan.FromSeconds(60));
_timer = new Timer(timerCallback, null, Timeout.Infinite, Timeout.Infinite);
_timer.Change(0, Timeout.Infinite);
_log.WriteLine("Sending event hub data");
}
catch (Exception exception)
{
Console.Error.WriteLine(exception.ToString());
}
finally
{
var exitEvent = new ManualResetEvent(false);
Console.CancelKeyPress += (sender, eventArgs) =>
{
Console.WriteLine("Stopping...");
eventArgs.Cancel = true;
exitEvent.Set();
};
exitEvent.WaitOne();
_timer.Change(Timeout.Infinite, Timeout.Infinite);
Thread.Sleep(_timerInterval);
_timer.Dispose();
eventHubSender.DisposeSender();
}
}
private static void RunTestSeq(EventHubConfig config, string messageBody, int iterations)
{
var _eventHubListener = new EventHubListener(config);
var _eventHubSender = new EventHubSender(config, messageBody, iterations);
_eventHubListener.StartListening().GetAwaiter().GetResult();
_eventHubSender.SendMessages().GetAwaiter().GetResult();
}
public void Send(string a)
{
var sas = GetSas();
//Console.WriteLine("Creating EHSender");
var xon = ServiceBusConnectionStringBuilder.CreateUsingSharedAccessSignature(new Uri(_sbNamespace), _hubName, _publisherName, sas);
var c = EventHubSender.CreateFromConnectionString(xon);
c.SendAsync(new EventData(System.Text.Encoding.UTF8.GetBytes($"{_publisherName} says {a}")));
//Console.WriteLine("Sent.");
}
private void SendTestEvent(object sender, RoutedEventArgs e)
{
var eventHubSender = new EventHubSender(
NamespaceTextBox.Text,
EventHubNameTextBox.Text,
EventHubPublisherTextBox.Text,
EventHubSasTokenTextBox.Text);
Task.Run(async() => await eventHubSender.SendAsync(new JsonObject()));
}
public IEventHubSender CreateEventHubSender(EventHubsConnectionStringBuilder connectionStringBuilder)
{
if (connectionStringBuilder == null)
{
throw new ArgumentNullException(nameof(connectionStringBuilder), "To create an event hub sender the connection string builder cannot be null");
}
var sender = new EventHubSender(connectionStringBuilder);
return(sender);
}
private void SendTestEvent(object sender, RoutedEventArgs e)
{
var eventHubSender = new EventHubSender(
NamespaceTextBox.Text,
EventHubNameTextBox.Text,
EventHubPublisherTextBox.Text,
EventHubSasTokenTextBox.Text);
eventHubSender.Enable();
eventHubSender.EnqueueEvent(new JsonObject());
}
static void Main(string[] args)
{
var logReader = new LogReader();
var logItems =
logReader.FileToDto <CarEventsDto>("..\\..\\..\\..\\1-Resources\\Data\\Ride.csv");
var ehSender = new EventHubSender();
ehSender.SendMessagesToEventHub(logItems).GetAwaiter().GetResult();
}
private static EventHubSender CreateSender()
{
var publisher = "handsonazurepublisher";
var token = SharedAccessSignatureTokenProvider.GetSharedAccessSignature(KeyName, SASKey,
$"sb://{Namespace}.servicebus.windows.net/{HubName}/publishers/{publisher}", TimeSpan.FromHours(24));
var connectionString =
ServiceBusConnectionStringBuilder.CreateUsingSharedAccessSignature(
new Uri($"sb://{Namespace}.servicebus.windows.net"), HubName, publisher, token);
var eventHubSender = EventHubSender.CreateFromConnectionString(connectionString);
return(eventHubSender);
}
public void SendDataTest()
{
var eventHubSender = new EventHubSender();
var startTime = DateTime.UtcNow;
_tollDataGenerator.Next(startTime, TimeSpan.FromSeconds(Convert.ToDouble(1)), 10);
foreach (var tollEvent in _tollDataGenerator.GetEvents(startTime))
{
eventHubSender.SendData(tollEvent);
}
}
private static void SendData(EventHubSender partitionedSender, InventoryTruck item)
{
// create the change event
var changeEvent = new InventoryChangeEvent() { ChangeType = InventoryChangeType.Refresh, Truck = item };
// create a memory stream with the XML serialized data and use to create event data object
var strm = SerializationHelper.SerializeToMemoryStream(changeEvent);
EventData data = new EventData(strm);
// send event data to Event Hub
partitionedSender.Send(data);
}
/// <summary>
/// Full constructor.
/// </summary>
/// <param name="connectionString">A connection string granting write access to the Azure event hub events are to be forwarded to.</param>
/// <param name="formatter">An <see cref="ILogEventFormatter"/> implementation used to format events before sending to Azure. If null then <see cref="Formatters.JsonLogEventFormatter.DefaultInstance"/> is used.</param>
/// <param name="useCompression">If true the system will gzip compress data before sending it to Azure.</param>
/// <exception cref="System.ArgumentNullException">Thrown if <paramref name="connectionString"/> is null.</exception>
/// <exception cref="System.ArgumentException">Thrown if <paramref name="connectionString"/> is empty or contains only whitespace.</exception>
public AzureEventHubLogWriter(string connectionString, ILogEventFormatter formatter, bool useCompression)
{
if (connectionString == null)
{
throw new ArgumentNullException(nameof(connectionString));
}
if (String.IsNullOrWhiteSpace(connectionString))
{
throw new ArgumentException(String.Format(System.Globalization.CultureInfo.CurrentCulture, Properties.Resources.PropertyCannotBeEmptyOrWhitespace, nameof(connectionString)), nameof(connectionString));
}
_Sender = new EventHubSender(connectionString, useCompression);
_Formatter = formatter;
}
private static void SendData(EventHubSender partitionedSender, InventoryTruck item)
{
// create the change event
var changeEvent = new InventoryChangeEvent()
{
ChangeType = InventoryChangeType.Refresh, Truck = item
};
// create a memory stream with the XML serialized data and use to create event data object
var strm = SerializationHelper.SerializeToMemoryStream(changeEvent);
EventData data = new EventData(strm);
// send event data to Event Hub
partitionedSender.Send(data);
}
public EventHubReporter(ServiceDescriptor service, EventHubConnectionInfo eventHubConnection)
{
Require.NotNull(service, nameof(service));
Require.NotNull(eventHubConnection, nameof(eventHubConnection));
var connectionString = ServiceBusConnectionStringBuilder.CreateUsingSharedAccessSignature(
endpoint: eventHubConnection.Namespace,
entityPath: eventHubConnection.Hub,
publisher: MetricsPublihser.GetPublisherId(service),
sharedAccessSignature: eventHubConnection.SharedAccessSignature);
m_service = service;
m_eventHubConnection = eventHubConnection;
m_sender = EventHubSender.CreateFromConnectionString(connectionString);
}
public EventSender(
Device device,
SimulatorConfiguration config,
Func <object, byte[]> serializer)
{
this._serializer = serializer;
var connectionString = ServiceBusConnectionStringBuilder.CreateUsingSharedAccessSignature(
device.Endpoint,
device.EventHubName,
device.Id,
device.Token
);
_eventHubSender = EventHubSender.CreateFromConnectionString(connectionString);
}
public void InitializeEventHub()
{
var builder = new ServiceBusConnectionStringBuilder();
builder.Endpoints.Add(new Uri("sb://" + this.appConfig.EventHubNamespace + "." + this.appConfig.EventHubFqnAddress));
builder.EntityPath = this.appConfig.EventHubEntityPath;
builder.SharedAccessKeyName = this.appConfig.EventHubUsername;
builder.SharedAccessKey = this.appConfig.EventHubPassword;
builder.TransportType = TransportType.Amqp;
Context.Logger.Info("EventHubWriter: ConnectionString = {0} ParitionId = {1}",
builder.ToString(), Context.TopologyContext.GetThisTaskIndex());
eventHubClient = EventHubClient.CreateFromConnectionString(builder.ToString());
//TODO: Implement a distribution strategy of partitions in case number of bolt tasks is less than partitions in EventHub
eventHubSender = eventHubClient.CreatePartitionedSender(Context.TopologyContext.GetThisTaskIndex().ToString());
}
private void InitialiseCapture()
{
if (pcarsUDPreader == null)
{
WriteToConsole("Initialising UDP Reader");
pcarsUDPreader = new PCarsAPI.PCarsUDPreader();
}
if (evHubSender == null)
{
WriteToConsole("Initialising Event Hub");
evHubSender = new EventHubSender();
evHubSender.Initialise(evHubConnString, evHubName);
WriteToConsole("Event Hub initialised");
}
StartListening();
}
private static Task SendTestMessage(CancellationToken token)
{
if (String.IsNullOrEmpty(ConnectionString))
{
Console.WriteLine("You must provision the device first.");
}
else
{
try
{
var sender = EventHubSender.CreateFromConnectionString(ConnectionString);
sender.Send(new EventData(Encoding.UTF8.GetBytes("Hello Event Hub")));
Console.WriteLine("Wrote data to event hub");
}
catch (Microsoft.ServiceBus.Messaging.PublisherRevokedException)
{
Console.WriteLine("The device was revoked. You must provision the device again.");
}
}
return(Task.FromResult(0));
}
public IEventHubSender CreateEventHubSender(string connectionString, string eventHubName)
{
if (string.IsNullOrWhiteSpace(connectionString))
{
throw new ArgumentException("To create an event hub sender the connection string cannot be null or empty", nameof(connectionString));
}
if (string.IsNullOrWhiteSpace(eventHubName))
{
throw new ArgumentException("To create an event hub sender the event hub name cannot be null or empty", nameof(eventHubName));
}
var connectionStringBuilder = new EventHubsConnectionStringBuilder(connectionString)
{
EntityPath = eventHubName
};
var sender = new EventHubSender(connectionStringBuilder);
return(sender);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, IHttpContextAccessor httpContextAccessor)
{
Log.Logger = new LoggerConfiguration()
.WriteTo.Console(new CompactJsonFormatter())
.ReadFrom.Configuration(Configuration)
.Enrich.With(new CorrelationLogEventEnricher(httpContextAccessor, Configuration["Logging:CorrelationHeaderKey"]))
.CreateLogger();
// Important: it has to be first: enable global logger
app.UseGlobalLoggerHandler();
// Important: it has to be second: Enable global exception, error handling
app.UseGlobalExceptionHandler();
// TODO: Add middleware AuthZ here
app.UseMvc();
// Enable middleware to serve generated Swagger as a JSON endpoint.
app.UseSwagger();
// Enable middleware to serve swagger-ui (HTML, JS, CSS etc.), specifying the Swagger JSON endpoint.
app.UseSwaggerUI(c =>
{
c.SwaggerEndpoint("/swagger/v1/swagger.json", "Fabrikam DroneDelivery DeliveryService API V1");
});
//TODO look into creating a factory of DocDBRepos/RedisCache/EventHubMessenger
DocumentDBRepository <InternalNotifyMeRequest> .Configure(Configuration["DOCDB_ENDPOINT"], Configuration["DOCDB_KEY"], Configuration["DOCDB_DATABASEID"], Configuration["DOCDB_COLLECTIONID"], loggerFactory);
RedisCache <InternalDelivery> .Configure(Constants.RedisCacheDBId_Delivery, Configuration["REDIS_CONNSTR"], loggerFactory);
RedisCache <DeliveryTrackingEvent> .Configure(Constants.RedisCacheDBId_DeliveryStatus, Configuration["REDIS_CONNSTR"], loggerFactory);
EventHubSender <DeliveryHistory> .Configure(Configuration["EH_CONNSTR"], Configuration["EH_ENTITYPATH"]);
EventHubSender <DeliveryHistory> .Configure(Configuration["EH_CONNSTR"], Configuration["EH_ENTITYPATH"]);
}
public void Scenario3_EventHubSendToPublisher(string eventHubEntity, string publisher)
{
ServiceBusConnectionStringBuilder builder = new ServiceBusConnectionStringBuilder(this.ConnectionString);
builder.TransportType = TransportType.Amqp;
MessagingFactory factory = MessagingFactory.CreateFromConnectionString(this.ConnectionString);
EventHubClient client = factory.CreateEventHubClient(eventHubEntity);
EventHubSender sender = client.CreateSender(publisher);
EventData data = new EventData(Encoding.UTF8.GetBytes("Body"));
data.Properties["time"] = DateTime.UtcNow;
sender.Send(data);
sender.Close();
client.Close();
factory.Close();
}
/// <summary>
/// Publish 10 Event Hub messages
/// </summary>
/// <param name="eventHubClient">EventHubClient object</param>
/// <returns>Task object</returns>
private async Task Publish10MessagesToEventHub(EventHubClient eventHubClient)
{
int maxMessagesToPublish = 10;
int successMessageSentCounter = 0;
Console.WriteLine($"About to publish [{maxMessagesToPublish}] message !\n");
for (var counter = 0; counter < maxMessagesToPublish; counter++)
{
try
{
var message = $"Sample event message {counter + 1}";
Console.WriteLine($"\tPublishing message content of [{message}]");
var eventData = new EventData(Encoding.UTF8.GetBytes(message));
EventHubSender eventHubSender = eventHubClient.CreatePartitionedSender(PARTITION_ID);
await eventHubSender.SendAsync(eventData);
Console.WriteLine($"\tPublishing message [{counter + 1}] is completed !\n");
successMessageSentCounter++;
}
catch (Exception exception)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Error occurred !");
Console.WriteLine(exception);
}
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Delay 1 seconds for the publish the next message !\n");
await Task.Delay(1000); // Delay 1 seconds for the publish the next message
}
if (successMessageSentCounter > 0)
{
Console.WriteLine($"[{successMessageSentCounter}] messages published successfully !\n");
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("No message published !");
}
}
static private void SendMessage(GDPRMessageWrapper message)
{
//send a message...
//string connectionStringBuilder = "Endpoint=sb://gdprevents.servicebus.windows.net/;SharedAccessKeyName=GDPRPolicy;SharedAccessKey=ecCNa0UQXlCFiAIbAOMCBJLbzlWqOaCI7YQX3DCmSgo=;EntityPath=gdprmessagehub";
string connectionStringBuilder = Util.EventHubConnectionStringWithPath;
eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString());
if (!string.IsNullOrEmpty(message.ApplicationId))
{
EventHubSender sender = eventHubClient.CreateSender("gdprgroup");
//EventHubSender sender = eventHubClient.CreatePartitionedSender("gdprgroup");
string msg = Newtonsoft.Json.JsonConvert.SerializeObject(message);
sender.Send(new EventData(Encoding.UTF8.GetBytes(msg)));
}
else
{
string msg = Newtonsoft.Json.JsonConvert.SerializeObject(message);
eventHubClient.Send(new EventData(Encoding.UTF8.GetBytes(msg)));
}
//eventHubClient.SendAsync(new EventData(Encoding.UTF8.GetBytes(msg)));
//eventHubClient.CloseAsync();
}
internal static void SendMessageToEventHub(string payload)
{
string connectionString = "Endpoint=sb://kioskeventhub.servicebus.windows.net/;SharedAccessKeyName=AllowSend;SharedAccessKey=tvzonqLkFUm+9AXlT/rq8Fmh0HlzND7MwOiGW6r0TNo=";
ServiceBusConnectionStringBuilder builder = new ServiceBusConnectionStringBuilder(connectionString);
builder.TransportType = TransportType.Amqp;
if (factory == null)
{
factory = MessagingFactory.CreateFromConnectionString(connectionString);
}
if (client == null)
{
client = factory.CreateEventHubClient("hub1");
}
EventHubSender sender = client.CreatePartitionedSender("partition");
EventData data = new EventData(Encoding.UTF8.GetBytes(payload));
data.Properties["time"] = DateTime.UtcNow;
sender.Send(data);
sender.Close();
}
/// <summary>
/// Create a new instance of the <see cref="EventHubSink"/>
/// </summary>
/// <param name="sender">The <see cref="EventHubSender"/> that sends the events to the EventHub</param>
public EventHubSink(EventHubSender sender) : this(new HubSenderWrapper(sender))
{
}
static void Main(string[] args)
{
if (1 > args.Length)
{
Usage();
return;
}
//
// Perform the operation indicated by the first command line
// argument
//
if (0 == String.Compare(args[0], OPERATION_REGISTER, true))
{
//
// Create an attested key
//
CngProvider cng = new CngProvider(SNKSP);
CngKeyCreationParameters createParams = new CngKeyCreationParameters();
createParams.Provider = cng;
createParams.KeyCreationOptions = CngKeyCreationOptions.None;
CngKey snKey = CngKey.Create(
CngAlgorithm2.Rsa, ATTESTED_KEY_NAME, createParams);
//
// Create a signed request message
//
StringBuilder pubKeyHashString = null;
byte[] registrationRequest = CryptoHelper.CreateMessageWithPrependedSignatureAndPublicKey(
snKey, ref pubKeyHashString);
//
// Save the message
//
File.WriteAllBytes(REQUEST_FILE_NAME, registrationRequest);
Console.WriteLine(
"Success: created registration request for publisher ID {0}",
pubKeyHashString);
}
else if (0 == String.Compare(args[0], OPERATION_PROVIDETOKEN, true))
{
//
// Receive the publisher token request
//
byte[] publisherTokenRequest = File.ReadAllBytes(REQUEST_FILE_NAME);
//
// Check the signature
//
StringBuilder publisherPubKeyHashString = null;
if (false == CryptoHelper.VerifyMessageWithPrependedSignatureAndPublicKey(
publisherTokenRequest, ref publisherPubKeyHashString))
{
return;
}
//
// Read the location of the StrongNet Attestation Server
//
RegistryKey snReg =
Registry.LocalMachine.OpenSubKey(SNKSP_REG_KEY, false);
string snAsUri = (string)snReg.GetValue(SNSERVICEURI_REG_VALUE);
//
// Confirm with the StrongNet Attestation Server that this is
// an attested key
//
var client = new RestClient(String.Format(
"{0}/{1}", snAsUri, SNAPI_ROOT));
var request = new RestRequest("MbkAttestation", Method.GET);
request.AddQueryParameter(
"publicKeyHash", publisherPubKeyHashString.ToString());
var response = client.Execute(request);
if (System.Net.HttpStatusCode.OK != response.StatusCode ||
ResponseStatus.Completed != response.ResponseStatus)
{
Console.WriteLine("Error: invalid publisher token request public key");
return;
}
//
// Using Publisher Policy, acquire a shared access token,
// simulating registration. This would happen on the server in
// order to limit exposure of the Azure access key.
//
// http://blogs.msdn.com/b/servicebus/archive/2015/02/02/event-hub-publisher-policy-in-action.aspx
//
// Timespan can be long if the registration server checks every
// publisher with the attestation server, the event processor checks a
// signature on every message, publisher IDs can be revoked, and
// you trust the storage of your policy key.
//
string token = SharedAccessSignatureTokenProvider.GetPublisherSharedAccessSignature(
new Uri(SERVICE_BUS_URI),
EVENT_HUB_NAME,
publisherPubKeyHashString.ToString(),
SENDER_POLICY_KEY_NAME,
args[1],
new TimeSpan(0, 30, 0));
//
// Send the token back to the requestor
//
File.WriteAllText(TOKEN_FILE_NAME, token);
Console.WriteLine(
"Success: issued SAS policy '{0}' token to publisher ID {1}",
SENDER_POLICY_KEY_NAME,
publisherPubKeyHashString);
}
else if (0 == String.Compare(args[0], OPERATION_SENDDATA, true))
{
//
// Read back a previously acquired Azure Service Bus publisher token
//
string token = File.ReadAllText(TOKEN_FILE_NAME);
//
// Open the attested key
//
CngProvider cng = new CngProvider(SNKSP);
CngKey snKey = CngKey.Open(ATTESTED_KEY_NAME, cng);
//
// Create a new signed message to simulate what will get posted
// by each sender to the event hub.
//
StringBuilder pubKeyHashString = null;
byte[] signedMessage = CryptoHelper.CreateMessageWithPrependedSignatureAndPublicKey(
snKey, ref pubKeyHashString);
//
// Create a connection string for this policy and hub. Using
// the hash of the public key as the publisher identity
// allows correlation between security policy compliance and
// sender data streams (but only if the processor verifies a
// message signature and that the public key is known to the
// attestation server).
//
string connStr = ServiceBusConnectionStringBuilder.CreateUsingSharedAccessSignature(
new Uri(SERVICE_BUS_URI),
EVENT_HUB_NAME,
pubKeyHashString.ToString(),
token);
//
// Create a sender for this connection
//
EventHubSender sender = EventHubSender.CreateFromConnectionString(connStr);
//
// Send the signed message
//
sender.Send(new EventData(signedMessage));
Console.WriteLine("Success: message sent");
}
else if (0 == String.Compare(args[0], OPERATION_LISTENDATA, true))
{
//
// Create a receiver for the indicated policy
//
string evtConnStr = ServiceBusConnectionStringBuilder.CreateUsingSharedAccessKey(
new Uri(SERVICE_BUS_URI), LISTEN_POLICY_KEY_NAME, args[1]);
string storageConnStr = string.Format(
"DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}",
args[2],
args[3]);
//
// Use a variation of multi-threaded listener sample code from
// Microsoft. This saves us from having to know which partition
// the test message got queued to.
//
// http://azure.microsoft.com/en-us/documentation/articles/service-bus-event-hubs-csharp-ephcs-getstarted/
//
var processorHost = new EventProcessorHost(
Guid.NewGuid().ToString(),
EVENT_HUB_NAME,
EventHubConsumerGroup.DefaultGroupName,
evtConnStr,
storageConnStr);
processorHost.RegisterEventProcessorAsync <SignatureCheckingEventProcessor>().Wait();
Console.WriteLine("Receiving. Press enter key to stop worker.");
Console.ReadLine();
}
else if (0 == String.Compare(args[0], OPERATION_REVOKEPUBLISHER, true))
{
//
// Create a namespace manager from a connection string acquired
// from the Azure management portal
//
var nsm = Microsoft.ServiceBus.NamespaceManager.CreateFromConnectionString(
args[1]);
//
// Revoke this publisher
//
nsm.RevokePublisher(EVENT_HUB_NAME, args[2]);
//
// List revoked publishers
//
var revokedPublishers = nsm.GetRevokedPublishers(EVENT_HUB_NAME);
//
// Restore this publisher
//
nsm.RestorePublisher(EVENT_HUB_NAME, args[2]);
}
else
{
Usage();
}
}
private static void CheckToken(string connStr)
{
var sender = EventHubSender.CreateFromConnectionString(connStr);
sender.Send(new EventData(Encoding.UTF8.GetBytes("Hello Event Hub")));
}
///// <summary>
///// This method can be used to send an event data to an event hub.
///// </summary>
///// <param name="eventHubClient">A EventHubSender object used to send messages.</param>
///// <param name="eventDataList">The list of messages to send.</param>
///// <param name="messageNumberList">The list of message numbers.</param>
///// <param name="taskId">The sender task id.</param>
///// <param name="logging">Indicates whether logging of message content and properties is enabled.</param>
///// <param name="verbose">Indicates whether verbose logging is enabled.</param>
///// <returns>Elapsed milliseconds.</returns>
public async Task<long> SendEventDataBatch(EventHubSender eventHubSender,
List<EventData> eventDataList,
List<long> messageNumberList,
int taskId,
bool logging,
bool verbose)
{
long elapsedMilliseconds = 0;
if (eventHubSender == null)
{
throw new ArgumentNullException(EventHubSenderCannotBeNull);
}
if (eventDataList == null || eventDataList.Count == 0)
{
return elapsedMilliseconds;
}
List<Stream> eventDataPayloadList = null;
var stopwatch = new Stopwatch();
var builder = new StringBuilder();
try
{
stopwatch.Start();
if (logging && verbose)
{
eventDataPayloadList = eventDataList.Select(e => e.Clone().GetBodyStream()).ToList();
}
await eventHubSender.SendBatchAsync(eventDataList);
}
finally
{
stopwatch.Stop();
}
elapsedMilliseconds = stopwatch.ElapsedMilliseconds;
if (logging)
{
for (var i = 0; i < eventDataList.Count; i++)
{
try
{
builder.AppendLine(string.Format(CultureInfo.CurrentCulture,
EventDataSuccessfullySent,
taskId,
messageNumberList[i],
string.IsNullOrWhiteSpace(eventDataList[i].PartitionKey)
? NullValue
: eventDataList[i].PartitionKey));
if (verbose)
{
builder.AppendLine(SentMessagePayloadHeader);
builder.AppendLine(string.Format(MessageTextFormat, GetMessageText(eventDataPayloadList[i])));
builder.AppendLine(SentMessagePropertiesHeader);
foreach (var p in eventDataList[i].Properties)
{
builder.AppendLine(string.Format(MessagePropertyFormat,
p.Key,
p.Value));
}
}
}
finally
{
eventDataList[i].Dispose();
}
}
var traceMessage = builder.ToString();
WriteToLog(traceMessage.Substring(0, traceMessage.Length - 1));
}
return elapsedMilliseconds;
}
public void Initialize(EventHubSender sender)
{
Sender = sender;
}
public BenefitController(ServiceBusTopic serviceBusTopic, EventHubSender eventHubSender)
{
_serviceBusTopic = serviceBusTopic;
_eventHubSender = eventHubSender;
}
public void InitializeEventHub()
{
Context.Logger.Info("Current AppConfig File: " + ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None));
Context.Logger.Info("Current AppSettings: " + String.Join(Environment.NewLine, ConfigurationManager.AppSettings.AllKeys));
this.EventHubNamespace = ConfigurationManager.AppSettings["EventHubNamespace"];
if (String.IsNullOrWhiteSpace(this.EventHubNamespace))
{
throw new ArgumentException("A required AppSetting cannot be null or empty", "EventHubNamespace");
}
this.EventHubEntityPath = ConfigurationManager.AppSettings["EventHubEntityPath"];
if (String.IsNullOrWhiteSpace(this.EventHubEntityPath))
{
throw new ArgumentException("A required AppSetting cannot be null or empty", "EventHubEntityPath");
}
this.EventHubSharedAccessKeyName = ConfigurationManager.AppSettings["EventHubSharedAccessKeyName"];
if (String.IsNullOrWhiteSpace(this.EventHubSharedAccessKeyName))
{
throw new ArgumentException("A required AppSetting cannot be null or empty", "EventHubSharedAccessKeyName");
}
this.EventHubSharedAccessKey = ConfigurationManager.AppSettings["EventHubSharedAccessKey"];
if (String.IsNullOrWhiteSpace(this.EventHubSharedAccessKey))
{
throw new ArgumentException("A required AppSetting cannot be null or empty", "EventHubSharedAccessKey");
}
this.EventHubPartitions = ConfigurationManager.AppSettings["EventHubPartitions"];
if (String.IsNullOrWhiteSpace(this.EventHubPartitions))
{
throw new ArgumentException("A required AppSetting cannot be null or empty", "EventHubPartitions");
}
var builder = new ServiceBusConnectionStringBuilder();
builder.Endpoints.Add(new Uri("sb://" + this.EventHubNamespace + "." + EventHubFqnAddress));
builder.EntityPath = this.EventHubEntityPath;
builder.SharedAccessKeyName = this.EventHubSharedAccessKeyName;
builder.SharedAccessKey = this.EventHubSharedAccessKey;
builder.TransportType = TransportType.Amqp;
var partitionCount = int.Parse(this.EventHubPartitions);
TopologyContext topologyContext = Context.TopologyContext;
Context.Logger.Info(this.GetType().Name + " TopologyContext info:");
Context.Logger.Info("TaskId: {0}", topologyContext.GetThisTaskId());
var taskIndex = topologyContext.GetThisTaskIndex();
Context.Logger.Info("TaskIndex: {0}", taskIndex);
string componentId = topologyContext.GetThisComponentId();
Context.Logger.Info("ComponentId: {0}", componentId);
List<int> componentTasks = topologyContext.GetComponentTasks(componentId);
Context.Logger.Info("ComponentTasks: {0}", componentTasks.Count);
if (partitionCount != componentTasks.Count)
{
throw new Exception(
String.Format("Component task count does not match partition count. Component: {0}, Tasks: {1}, Partition: {2}",
componentId, componentTasks.Count, partitionCount));
}
partitionId = taskIndex.ToString();
Context.Logger.Info(this.GetType().Name + " ConnectionString = {0}, ParitionId = {1}",
builder.ToString(), partitionId);
eventHubClient = EventHubClient.CreateFromConnectionString(builder.ToString());
eventHubSender = eventHubClient.CreatePartitionedSender(partitionId);
}
/// <summary>
/// Shurtcut for running this <see cref="Source{TOut,TMat}"/> with a <see cref="EventHubSink"/>.
/// The returned <see cref="Task"/> will be completed with Success when reaching the
/// normal end of the stream, or completed with Failure if there is a failure signaled in the stream.
/// </summary>
public static Task ToEventHub <TMat>(this Source <IEnumerable <EventData>, TMat> source, EventHubSender sender, IMaterializer materializer)
{
return(source.RunWith(new EventHubSink(sender), materializer));
}
/// <summary>
/// This method can be used to send an event data to an event hub.
/// </summary>
/// <param name="eventHubSender">A EventHubSender object used to send event data.</param>
/// <param name="eventData">The event data to send.</param>
/// <param name="messageNumber">The message number.</param>
/// <param name="taskId">The sender task id.</param>
/// <param name="logging">Indicates whether logging of event data content and properties is enabled.</param>
/// <param name="verbose">Indicates whether verbose logging is enabled.</param>
/// <returns>Elapsed milliseconds.</returns>
public async Task<long> SendEventData(EventHubSender eventHubSender,
EventData eventData,
long messageNumber,
int taskId,
bool logging,
bool verbose)
{
long elapsedMilliseconds;
if (eventHubSender == null)
{
throw new ArgumentNullException(EventHubSenderCannotBeNull);
}
if (eventData == null)
{
throw new ArgumentNullException(EventDataCannotBeNull);
}
var stopwatch = new Stopwatch();
Stream bodyStream = null;
try
{
var builder = new StringBuilder();
try
{
if (logging && verbose)
{
bodyStream = eventData.Clone().GetBodyStream();
}
stopwatch.Start();
await eventHubSender.SendAsync(eventData);
}
finally
{
stopwatch.Stop();
}
elapsedMilliseconds = stopwatch.ElapsedMilliseconds;
if (logging)
{
builder.AppendLine(string.Format(CultureInfo.CurrentCulture,
EventDataSuccessfullySent,
taskId,
messageNumber,
string.IsNullOrWhiteSpace(eventData.PartitionKey) ? NullValue : eventData.PartitionKey));
if (verbose)
{
builder.AppendLine(SentMessagePayloadHeader);
builder.AppendLine(string.Format(MessageTextFormat, GetMessageText(bodyStream)));
if (eventData.Properties.Any())
{
builder.AppendLine(SentMessagePropertiesHeader);
foreach (var p in eventData.Properties)
{
builder.AppendLine(string.Format(MessagePropertyFormat,
p.Key,
p.Value));
}
}
}
var traceMessage = builder.ToString();
WriteToLog(traceMessage.Substring(0, traceMessage.Length - 1));
}
}
finally
{
eventData.Dispose();
}
return elapsedMilliseconds;
}
public void InitializeEventHub()
{
Context.Logger.Info("Initializing EventHubClient and EventHubSender...");
var builder = new ServiceBusConnectionStringBuilder();
builder.Endpoints.Add(new Uri("sb://" + this.appConfig.EventHubNamespace + "." + this.appConfig.EventHubFqnAddress));
builder.EntityPath = this.appConfig.EventHubEntityPath;
builder.SharedAccessKeyName = this.appConfig.EventHubSharedAccessKeyName;
builder.SharedAccessKey = this.appConfig.EventHubSharedAccessKey;
builder.TransportType = TransportType.Amqp;
Context.Logger.Info("EventHubWriter: ConnectionString = {0} ParitionId = {1}",
builder.ToString(), Context.TopologyContext.GetThisTaskIndex());
eventHubClient = EventHubClient.CreateFromConnectionString(builder.ToString());
//TODO: Implement a distribution strategy of partitions in case number of bolt tasks is less than partitions in EventHub
eventHubSender = eventHubClient.CreatePartitionedSender(Context.TopologyContext.GetThisTaskIndex().ToString());
}
public HubSenderWrapper(EventHubSender sender)
{
_sender = sender;
}
public void InitializeEventHub()
{
Context.Logger.Info("Current AppConfig File: " + ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None));
Context.Logger.Info("Current AppSettings: " + String.Join(Environment.NewLine, ConfigurationManager.AppSettings.AllKeys));
this.EventHubNamespace = ConfigurationManager.AppSettings["EventHubNamespace"];
if (String.IsNullOrWhiteSpace(this.EventHubNamespace))
{
throw new ArgumentException("A required AppSetting cannot be null or empty", "EventHubNamespace");
}
this.EventHubEntityPath = ConfigurationManager.AppSettings["EventHubEntityPath"];
if (String.IsNullOrWhiteSpace(this.EventHubEntityPath))
{
throw new ArgumentException("A required AppSetting cannot be null or empty", "EventHubEntityPath");
}
this.EventHubSharedAccessKeyName = ConfigurationManager.AppSettings["EventHubSharedAccessKeyName"];
if (String.IsNullOrWhiteSpace(this.EventHubSharedAccessKeyName))
{
throw new ArgumentException("A required AppSetting cannot be null or empty", "EventHubSharedAccessKeyName");
}
this.EventHubSharedAccessKey = ConfigurationManager.AppSettings["EventHubSharedAccessKey"];
if (String.IsNullOrWhiteSpace(this.EventHubSharedAccessKey))
{
throw new ArgumentException("A required AppSetting cannot be null or empty", "EventHubSharedAccessKey");
}
this.EventHubPartitions = ConfigurationManager.AppSettings["EventHubPartitions"];
if (String.IsNullOrWhiteSpace(this.EventHubPartitions))
{
throw new ArgumentException("A required AppSetting cannot be null or empty", "EventHubPartitions");
}
var builder = new ServiceBusConnectionStringBuilder();
builder.Endpoints.Add(new Uri("sb://" + this.EventHubNamespace + "." + EventHubFqnAddress));
builder.EntityPath = this.EventHubEntityPath;
builder.SharedAccessKeyName = this.EventHubSharedAccessKeyName;
builder.SharedAccessKey = this.EventHubSharedAccessKey;
builder.TransportType = TransportType.Amqp;
var partitionCount = int.Parse(this.EventHubPartitions);
TopologyContext topologyContext = Context.TopologyContext;
Context.Logger.Info(this.GetType().Name + " TopologyContext info:");
Context.Logger.Info("TaskId: {0}", topologyContext.GetThisTaskId());
var taskIndex = topologyContext.GetThisTaskIndex();
Context.Logger.Info("TaskIndex: {0}", taskIndex);
string componentId = topologyContext.GetThisComponentId();
Context.Logger.Info("ComponentId: {0}", componentId);
List <int> componentTasks = topologyContext.GetComponentTasks(componentId);
Context.Logger.Info("ComponentTasks: {0}", componentTasks.Count);
if (partitionCount != componentTasks.Count)
{
throw new Exception(
String.Format("Component task count does not match partition count. Component: {0}, Tasks: {1}, Partition: {2}",
componentId, componentTasks.Count, partitionCount));
}
partitionId = taskIndex.ToString();
Context.Logger.Info(this.GetType().Name + " ConnectionString = {0}, ParitionId = {1}",
builder.ToString(), partitionId);
eventHubClient = EventHubClient.CreateFromConnectionString(builder.ToString());
eventHubSender = eventHubClient.CreatePartitionedSender(partitionId);
}
