/// <summary>
/// Create a new host to process events from an Event Hub.
///
/// <para>This overload of the constructor allows maximum flexibility.
/// This one allows the caller to specify the name of the processor host as well.
/// The overload also allows the caller to provide their own lease and checkpoint managers to replace the built-in
/// ones based on Azure Storage.</para>
/// </summary>
/// <param name="hostName">Name of the processor host. MUST BE UNIQUE. Strongly recommend including a Guid to ensure uniqueness.</param>
/// <param name="eventHubPath">The name of the EventHub.</param>
/// <param name="consumerGroupName">The name of the consumer group within the Event Hub.</param>
/// <param name="eventHubConnectionString">Connection string for the Event Hub to receive from.</param>
/// <param name="checkpointManager">Object implementing ICheckpointManager which handles partition checkpointing.</param>
/// <param name="leaseManager">Object implementing ILeaseManager which handles leases for partitions.</param>
public EventProcessorHost(
string hostName,
string eventHubPath,
string consumerGroupName,
string eventHubConnectionString,
ICheckpointManager checkpointManager,
ILeaseManager leaseManager)
{
if (string.IsNullOrEmpty(consumerGroupName))
{
throw new ArgumentNullException(nameof(consumerGroupName));
}
else if (checkpointManager == null || leaseManager == null)
{
throw new ArgumentNullException(checkpointManager == null ? nameof(checkpointManager) : nameof(leaseManager));
}
var csb = new EventHubsConnectionStringBuilder(eventHubConnectionString);
if (string.IsNullOrEmpty(eventHubPath))
{
// Entity path is expected in the connection string if not provided with eventHubPath parameter.
if (string.IsNullOrEmpty(csb.EntityPath))
{
throw new ArgumentException(nameof(eventHubConnectionString),
"Provide EventHub entity path either in eventHubPath parameter or in eventHubConnectionString.");
}
}
else
{
// Entity path should not conflict with connection string.
if (!string.IsNullOrEmpty(csb.EntityPath) &&
string.Compare(csb.EntityPath, eventHubPath, StringComparison.OrdinalIgnoreCase) != 0)
{
throw new ArgumentException(nameof(eventHubConnectionString),
"Provided EventHub path in eventHubPath parameter conflicts with the path in provided EventHubs connection string.");
}
csb.EntityPath = eventHubPath;
}
this.HostName = hostName;
this.EventHubPath = csb.EntityPath;
this.ConsumerGroupName = consumerGroupName;
this.EventHubConnectionString = csb.ToString();
this.CheckpointManager = checkpointManager;
this.LeaseManager = leaseManager;
this.Id = $"EventProcessorHost({hostName.Substring(0, Math.Min(hostName.Length, 20))}...)";
this.PartitionManager = new PartitionManager(this);
ProcessorEventSource.Log.EventProcessorHostCreated(this.Id, this.EventHubPath);
}
public async Task SendDataAsync(string data, string eventHubName, string eventHubConnectionString)
{
var eventData = new EventData(Encoding.UTF8.GetBytes(data));
var connectionStringBuilder = new EventHubsConnectionStringBuilder(eventHubConnectionString)
{
EntityPath = eventHubName
};
var eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString());
await eventHubClient.SendAsync(eventData);
_logger.LogInformation("Data sent to event hub");
}
/// <summary>
/// Constructor. Arguments break down into three groups: (1) Service Fabric objects so this library can access
/// Service Fabric facilities, (2) Event Hub-related arguments which indicate what event hub to receive from and
/// how to process the events, and (3) advanced, which right now consists only of the ability to replace the default
/// reliable dictionary-based checkpoint manager with a user-provided implementation.
/// </summary>
/// <param name="serviceFabricServiceName">Service Fabric Uri found in StatefulServiceContext</param>
/// <param name="serviceFabricPartitionId">Service Fabric partition id found in StatefulServiceContext</param>
/// <param name="stateManager">Service Fabric-provided state manager, provides access to reliable dictionaries</param>
/// <param name="partition">Service Fabric-provided partition information</param>
/// <param name="userEventProcessor">User's event processor implementation</param>
/// <param name="eventHubConnectionString">Connection string for user's event hub</param>
/// <param name="eventHubConsumerGroup">Name of event hub consumer group to receive from</param>
/// <param name="options">Optional: Options structure for ServiceFabricProcessor library</param>
/// <param name="checkpointManager">Very advanced/optional: user-provided checkpoint manager implementation</param>
public ServiceFabricProcessor(Uri serviceFabricServiceName, Guid serviceFabricPartitionId, IReliableStateManager stateManager, IStatefulServicePartition partition, IEventProcessor userEventProcessor,
string eventHubConnectionString, string eventHubConsumerGroup,
EventProcessorOptions options = null, ICheckpointMananger checkpointManager = null)
{
if (serviceFabricServiceName == null)
{
throw new ArgumentNullException("serviceFabricServiceName is null");
}
if (serviceFabricPartitionId == null)
{
throw new ArgumentNullException("serviceFabricPartitionId is null");
}
if (stateManager == null)
{
throw new ArgumentNullException("stateManager is null");
}
if (partition == null)
{
throw new ArgumentNullException("partition is null");
}
if (userEventProcessor == null)
{
throw new ArgumentNullException("userEventProcessor is null");
}
if (string.IsNullOrEmpty(eventHubConnectionString))
{
throw new ArgumentException("eventHubConnectionString is null or empty");
}
if (string.IsNullOrEmpty(eventHubConsumerGroup))
{
throw new ArgumentException("eventHubConsumerGroup is null or empty");
}
this.serviceFabricServiceName = serviceFabricServiceName;
this.serviceFabricPartitionId = serviceFabricPartitionId;
this.serviceStateManager = stateManager;
this.servicePartition = partition;
this.userEventProcessor = userEventProcessor;
this.ehConnectionString = new EventHubsConnectionStringBuilder(eventHubConnectionString);
this.consumerGroupName = eventHubConsumerGroup;
this.options = options ?? new EventProcessorOptions();
this.checkpointManager = checkpointManager ?? new ReliableDictionaryCheckpointMananger(this.serviceStateManager);
this.EventHubClientFactory = new EventHubWrappers.EventHubClientFactory();
this.TestMode = false;
this.MockMode = null;
}
public EventHubSenderWrapper()
{
EventHubConfig.EventHubName = EventHubName;
EventHubConfig.WriteConnectionString = EventHubConnectionString;
var eventHubConfigProvider = EventHubConfig.EventHubConfigProvider;
var connectionStringBuilder = new EventHubsConnectionStringBuilder(EventHubConfig.WriteConnectionString)
{
EntityPath = EventHubConfig.EventHubName
};
_sender = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString());
}
protected async Task VerifyDataOnIoTHub(string moduleId)
{
var builder = new EventHubsConnectionStringBuilder(this.eventhubCompatibleEndpointWithEntityPath);
builder.TransportType = this.eventHubClientTransportType;
Console.WriteLine($"Receiving events from device '{this.context.Device.Id}' on Event Hub '{builder.EntityPath}'");
EventHubClient eventHubClient =
EventHubClient.CreateFromConnectionString(builder.ToString());
PartitionReceiver eventHubReceiver = eventHubClient.CreateReceiver(
"$Default",
EventHubPartitionKeyResolver.ResolveToPartition(
this.context.Device.Id,
(await eventHubClient.GetRuntimeInformationAsync()).PartitionCount),
EventPosition.FromEnd());
var result = new TaskCompletionSource <bool>();
using (var cts = new CancellationTokenSource(TimeSpan.FromMinutes(10)))
{
using (cts.Token.Register(() => result.TrySetCanceled()))
{
eventHubReceiver.SetReceiveHandler(
new PartitionReceiveHandler(
eventData =>
{
eventData.SystemProperties.TryGetValue("iothub-connection-device-id", out object devId);
eventData.SystemProperties.TryGetValue("iothub-connection-module-id", out object modId);
if (devId != null && devId.ToString().Equals(this.context.Device.Id) &&
modId != null && modId.ToString().Equals(moduleId))
{
result.TrySetResult(true);
return(true);
}
return(false);
}));
await result.Task;
}
}
Console.WriteLine("VerifyDataOnIoTHub completed.");
await eventHubReceiver.CloseAsync();
await eventHubClient.CloseAsync();
}
public void Initialize(string connectionString, string eventHubName)
{
this.connectionString = connectionString;
this.eventHubName = eventHubName;
var connectionStringBuilder = new EventHubsConnectionStringBuilder(connectionString)
{
EntityPath = eventHubName
};
var fullConnectionString = connectionStringBuilder.ToString();
client = EventHubClient.CreateFromConnectionString(fullConnectionString);
}
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequestMessage req, TraceWriter log)
{
var STORAGE_ACCT = System.Environment.GetEnvironmentVariable("STORAGE_ACCT", EnvironmentVariableTarget.Process);
var STORAGE_ACCT_KEY = System.Environment.GetEnvironmentVariable("STORAGE_ACCT_KEY", EnvironmentVariableTarget.Process);
var EVENT_HUB_CONN = System.Environment.GetEnvironmentVariable("EVENT_HUB_CONN", EnvironmentVariableTarget.Process);
var EhEntityPath = "deployqueue";
// Connect to EH
var connectionStringBuilder = new EventHubsConnectionStringBuilder(EVENT_HUB_CONN)
{
EntityPath = EhEntityPath
};
var eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString());
CloudStorageAccount storageAccount = new CloudStorageAccount(
new Microsoft.WindowsAzure.Storage.Auth.StorageCredentials(
STORAGE_ACCT,
STORAGE_ACCT_KEY), true);
// Create a blob client.
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
// Get a reference to a container named "mycontainer."
CloudBlobContainer container = blobClient.GetContainerReference("testblah");
// Get blob
CloudBlockBlob blockBlob = container.GetBlockBlobReference("azuredeploy.json");
// Save blog to text var
var templateContent = await blockBlob.DownloadTextAsync();
//log.Info(templateContent);
JObject template = JObject.Parse(templateContent);
JObject templateParams = (JObject)template["parameters"];
//log.Info(templateParams["adminUsername"]["defaultValue"].ToString());
templateParams["adminUsername"]["defaultValue"] = "esell";
templateParams["adminPassword"]["defaultValue"] = "B3stP4ss0nTheN3t!";
templateParams["dnsLabelPrefix"]["defaultValue"] = "esellautogen";
try
{
await eventHubClient.SendAsync(new EventData(Encoding.UTF8.GetBytes(template.ToString())));
}
catch (Exception ex) {
log.Error(ex.Message);
}
return(req.CreateResponse(HttpStatusCode.OK, template.ToString()));
}
public static async Task ClassInitialize(TestContext context)
{
if (context.Properties.TryGetValue("EventHubNamespaceConnectionString", out object connectionStringValue) &&
connectionStringValue is string connectionString &&
context.Properties.TryGetValue("EventHubName", out object eventHubNameValue) &&
eventHubNameValue is string eventHubName)
{
var connectionStringBuilder = new EventHubsConnectionStringBuilder(connectionString)
{
EntityPath = eventHubName
};
EventHub = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString());
EventHubInformation = await EventHub.GetRuntimeInformationAsync();
}
public async Task <string> GetConnectionStringAsync(string eventHub)
{
await EnsureAuthenticatedAsync();
AzureOperationResponse <AccessKeys> responseKeys = await _client.EventHubs.ListKeysWithHttpMessagesAsync(_azureResourceIdentifier.ResourceGroupName,
_azureResourceIdentifier.Name, eventHub, "sender");
AccessKeys keys = responseKeys.Body;
var eventHubNamespaceUri = new Uri($"sb://{_azureResourceIdentifier.Name}.servicebus.windows.net");
var connectionStringBuilder = new EventHubsConnectionStringBuilder(eventHubNamespaceUri, eventHub, keys.KeyName, keys.PrimaryKey);
return(connectionStringBuilder.ToString());
}
private EventHubClient CreateClient()
{
// Creates an EventHubsConnectionStringBuilder object from the connection string, and sets the EntityPath.
// Typically, the connection string should have the entity path in it, but this simple scenario
// uses the connection string from the namespace.
var connectionStringBuilder = new EventHubsConnectionStringBuilder(config.EventHubConnectionString)
{
EntityPath = EventHubName
};
var eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString());
return(eventHubClient);
}
public async Task GetEventHubPartitionRuntimeInformation()
{
var cbs = new EventHubsConnectionStringBuilder(TestUtility.EventHubsConnectionString);
var ehClient = EventHubClient.CreateFromConnectionString(TestUtility.EventHubsConnectionString);
var partitions = await this.GetPartitionsAsync(ehClient);
try
{
TestUtility.Log("Getting EventHubPartitionRuntimeInformation on each partition in parallel");
var tasks = partitions.Select(async(pid) =>
{
// Send some messages so we can have meaningful data returned from service call.
PartitionSender partitionSender = ehClient.CreatePartitionSender(pid);
try
{
TestUtility.Log($"Sending single event to partition {pid}");
var eDataToSend = new EventData(new byte[1]);
await partitionSender.SendAsync(eDataToSend);
TestUtility.Log($"Getting partition runtime information on partition {pid}");
var partition = await ehClient.GetPartitionRuntimeInformationAsync(pid);
TestUtility.Log($"Path:{partition.Path} PartitionId:{partition.PartitionId} BeginSequenceNumber:{partition.BeginSequenceNumber} LastEnqueuedOffset:{partition.LastEnqueuedOffset} LastEnqueuedTimeUtc:{partition.LastEnqueuedTimeUtc} LastEnqueuedSequenceNumber:{partition.LastEnqueuedSequenceNumber}");
// Validations.
Assert.True(partition.Path == cbs.EntityPath, $"Returned path {partition.Path} is different than {cbs.EntityPath}");
Assert.True(partition.PartitionId == pid, $"Returned partition id {partition.PartitionId} is different than {pid}");
Assert.True(partition.LastEnqueuedOffset != null, "Returned LastEnqueuedOffset is null");
Assert.True(partition.LastEnqueuedTimeUtc != null, "Returned LastEnqueuedTimeUtc is null");
// Validate returned data regarding recently sent event.
// Account 60 seconds of max clock skew.
Assert.True(partition.LastEnqueuedOffset != "-1", $"Returned LastEnqueuedOffset is {partition.LastEnqueuedOffset}");
Assert.True(partition.BeginSequenceNumber >= 0, $"Returned BeginSequenceNumber is {partition.BeginSequenceNumber}");
Assert.True(partition.LastEnqueuedSequenceNumber >= 0, $"Returned LastEnqueuedSequenceNumber is {partition.LastEnqueuedSequenceNumber}");
Assert.True(partition.LastEnqueuedTimeUtc >= DateTime.UtcNow.AddSeconds(-60), $"Returned LastEnqueuedTimeUtc is {partition.LastEnqueuedTimeUtc}");
}
finally
{
await partitionSender.CloseAsync();
}
});
await Task.WhenAll(tasks);
}
finally
{
await ehClient.CloseAsync();
}
}
private EventHubClient InitializeEventHub()
{
logger.LogInformation("Creating EventHub");
var ehConnectionString = eventHubSettings.EventHubConnectionString;
var entityPath = eventHubSettings.EventHubPath;
var connectionStringBuilder = new EventHubsConnectionStringBuilder(ehConnectionString)
{
EntityPath = entityPath
};
return(EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString()));
}
/// <summary>
/// This registers <see cref="IEventProcessorFactory"/> implementation with the host which is used to create an instance of
/// <see cref="IEventProcessor"/> when it takes ownership of a partition. This also starts the host and causes it to start participating
/// in the partition distribution process.
/// </summary>
/// <param name="factory">Instance of <see cref="IEventProcessorFactory"/> implementation.</param>
/// <param name="processorOptions"><see cref="EventProcessorOptions"/> to control various aspects of message pump created when ownership
/// is acquired for a particular partition of EventHub.</param>
/// <returns>A task to indicate EventProcessorHost instance is started.</returns>
public async Task RegisterEventProcessorFactoryAsync(IEventProcessorFactory factory, EventProcessorOptions processorOptions)
{
if (factory == null || processorOptions == null)
{
throw new ArgumentNullException(factory == null ? nameof(factory) : nameof(processorOptions));
}
// Initialize partition manager options with default values if not already set by the client.
if (this.PartitionManagerOptions == null)
{
// Assign partition manager with default options.
this.PartitionManagerOptions = new PartitionManagerOptions();
}
ProcessorEventSource.Log.EventProcessorHostOpenStart(this.HostName, factory.GetType().ToString());
try
{
// Override operation timeout by receive timeout?
if (processorOptions.ReceiveTimeout > TimeSpan.MinValue)
{
this.OperationTimeout = processorOptions.ReceiveTimeout;
if (this.eventHubConnectionString != null)
{
var cbs = new EventHubsConnectionStringBuilder(this.eventHubConnectionString)
{
OperationTimeout = processorOptions.ReceiveTimeout
};
this.eventHubConnectionString = cbs.ToString();
}
}
// Initialize lease manager if this is an AzureStorageCheckpointLeaseManager
(this.LeaseManager as AzureStorageCheckpointLeaseManager)?.Initialize(this);
this.ProcessorFactory = factory;
this.EventProcessorOptions = processorOptions;
await this.PartitionManager.StartAsync().ConfigureAwait(false);
}
catch (Exception e)
{
ProcessorEventSource.Log.EventProcessorHostOpenError(this.HostName, e.ToString());
throw;
}
finally
{
ProcessorEventSource.Log.EventProcessorHostOpenStop(this.HostName);
}
}
private static EventHubClient CreateClient(string eventHubName, string connection)
{
EnsureArg.IsNotNullOrWhiteSpace(eventHubName, nameof(eventHubName));
EnsureArg.IsNotNullOrWhiteSpace(connection, nameof(connection));
var sb = new EventHubsConnectionStringBuilder(connection);
if (string.IsNullOrWhiteSpace(sb.EntityPath))
{
sb.EntityPath = eventHubName;
}
return(EventHubClient.CreateFromConnectionString(sb.ToString()));
}
private static async Task MainEventHubAsync(string[] args)
{
WriteLine("Enter your Event Hub connection string:");
var EventHubConnectionString = ReadLine();
while (EventHubConnectionString.Length == 0)
{
WriteLine("Try again, this value must have a length > 0");
WriteLine("Enter your Event Hub connection string:");
EventHubConnectionString = ReadLine();
}
WriteLine("Enter your Event Hub name:");
var EventHubName = ReadLine();
while (EventHubName.Length == 0)
{
WriteLine("Try again, this value must have a length > 0");
WriteLine("Enter your Event Hub name:");
EventHubName = ReadLine();
}
WriteLine("Enter your path where the Video Event files are:");
var pathofVidEVTfiles = ReadLine();
while (pathofVidEVTfiles.Length == 0)
{
WriteLine("Try again, this value must have a length > 0");
WriteLine("Enter your path where the Video Event files are:");
pathofVidEVTfiles = ReadLine();
}
WriteLine("Enter number of events to add: ");
int EventHubEventsToSend = 0;
while (!int.TryParse(ReadLine(), out EventHubEventsToSend))
{
WriteLine("Try again, this value must be numeric.");
}
var connectionStringBuilder = new EventHubsConnectionStringBuilder(EventHubConnectionString)
{
EntityPath = EventHubName
};
eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString());
await SendMessagesToEventHub(EventHubEventsToSend, pathofVidEVTfiles);
await eventHubClient.CloseAsync();
}
protected async Task VerifyDataOnIoTHubAsync()
{
var builder = new EventHubsConnectionStringBuilder(this.eventhubCompatibleEndpointWithEntityPath)
{
TransportType = this.eventHubClientTransportType
};
Console.WriteLine($"Receiving events from device '{this.context.Device.Id}' on Event Hub '{builder.EntityPath}'");
EventHubClient eventHubClient =
EventHubClient.CreateFromConnectionString(builder.ToString());
PartitionReceiver eventHubReceiver = eventHubClient.CreateReceiver(
"$Default",
EventHubPartitionKeyResolver.ResolveToPartition(
this.context.Device.Id,
(await eventHubClient.GetRuntimeInformationAsync()).PartitionCount),
EventPosition.FromEnqueuedTime(DateTime.Now.AddMinutes(-5)));
var result = new TaskCompletionSource <bool>();
using (var cts = new CancellationTokenSource(TimeSpan.FromMinutes(3)))
{
using (cts.Token.Register(() => result.TrySetCanceled()))
{
eventHubReceiver.SetReceiveHandler(
new PartitionReceiveHandler(
eventData =>
{
eventData.SystemProperties.TryGetValue("iothub-connection-device-id", out var devId);
if (devId != null && devId.ToString().Equals(this.context.Device.Id, StringComparison.Ordinal) &&
Encoding.UTF8.GetString(eventData.Body).Contains(this.context.MessageGuid, StringComparison.Ordinal))
{
result.TrySetResult(true);
return(true);
}
return(false);
}));
await result.Task;
}
}
await eventHubReceiver.CloseAsync();
await eventHubClient.CloseAsync();
}
/// <summary>
/// Create a new host to process events from an Event Hub.
///
/// <para>This overload of the constructor allows maximum flexibility.
/// This one allows the caller to specify the name of the processor host as well.
/// The overload also allows the caller to provide their own lease and checkpoint managers to replace the built-in
/// ones based on Azure Storage.</para>
/// </summary>
/// <param name="hostName">Name of the processor host. MUST BE UNIQUE. Strongly recommend including a Guid to ensure uniqueness.</param>
/// <param name="eventHubPath">The name of the EventHub.</param>
/// <param name="consumerGroupName">The name of the consumer group within the Event Hub.</param>
/// <param name="eventHubConnectionString">Connection string for the Event Hub to receive from.</param>
/// <param name="checkpointManager">Object implementing ICheckpointManager which handles partition checkpointing.</param>
/// <param name="leaseManager">Object implementing ILeaseManager which handles leases for partitions.</param>
public EventProcessorHost(
string hostName,
string eventHubPath,
string consumerGroupName,
string eventHubConnectionString,
ICheckpointManager checkpointManager,
ILeaseManager leaseManager)
{
Guard.ArgumentNotNullOrWhiteSpace(nameof(hostName), hostName);
Guard.ArgumentNotNullOrWhiteSpace(nameof(consumerGroupName), consumerGroupName);
Guard.ArgumentNotNull(nameof(checkpointManager), checkpointManager);
Guard.ArgumentNotNull(nameof(leaseManager), leaseManager);
var csb = new EventHubsConnectionStringBuilder(eventHubConnectionString);
if (string.IsNullOrEmpty(eventHubPath))
{
// Entity path is expected in the connection string if not provided with eventHubPath parameter.
if (string.IsNullOrEmpty(csb.EntityPath))
{
throw new ArgumentException(nameof(eventHubConnectionString),
"Provide EventHub entity path either in eventHubPath parameter or in eventHubConnectionString.");
}
}
else
{
// Entity path should not conflict with connection string.
if (!string.IsNullOrEmpty(csb.EntityPath) &&
string.Compare(csb.EntityPath, eventHubPath, StringComparison.OrdinalIgnoreCase) != 0)
{
throw new ArgumentException(nameof(eventHubConnectionString),
"Provided EventHub path in eventHubPath parameter conflicts with the path in provided EventHubs connection string.");
}
csb.EntityPath = eventHubPath;
}
this.HostName = hostName;
this.EventHubPath = csb.EntityPath;
this.ConsumerGroupName = consumerGroupName;
this.eventHubConnectionString = csb.ToString();
this.CheckpointManager = checkpointManager;
this.LeaseManager = leaseManager;
this.TransportType = csb.TransportType;
this.OperationTimeout = csb.OperationTimeout;
this.EndpointAddress = csb.Endpoint;
this.PartitionManager = new PartitionManager(this);
ProcessorEventSource.Log.EventProcessorHostCreated(this.HostName, this.EventHubPath);
}
private static async Task MainAsync(string[] args)
{
var builder = new ConfigurationBuilder()
.AddEnvironmentVariables();
var configuration = builder.Build();
var connectionString = configuration["EVENTHUB_SENDER_CONNECTION_STRING"];
var connectionStringBuilder = new EventHubsConnectionStringBuilder(connectionString);
_client = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString());
await SendBatchesToEventHub(100000, 1000);
await _client.CloseAsync();
}
/// <summary>
/// Registers a command auditor that writes to an event hub
/// </summary>
/// <param name="resolver">Dependency resolver</param>
/// <param name="connectionString">Connection string to an event hub e.g.:
/// Endpoint=sb://myeventhub.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=mysharedaccesskey
/// </param>
/// <param name="entityPath">The path to the event hub (usually just the event hub name</param>
/// <param name="partitionKeyProvider">An optional partition key provider, if unspecified events will be sent unpartitioned</param>
/// <param name="options">Options for the event hub auditor configuration</param>
/// <returns>Dependency resolver</returns>
public static ICommandingDependencyResolverAdapter AddEventHubCommandAuditing(this ICommandingDependencyResolverAdapter resolver,
string connectionString,
string entityPath,
IPartitionKeyProvider partitionKeyProvider = null,
AzureEventHubAuditorOptions options = null)
{
EventHubsConnectionStringBuilder builder =
new EventHubsConnectionStringBuilder(connectionString)
{
EntityPath = entityPath
};
Microsoft.Azure.EventHubs.EventHubClient client = Microsoft.Azure.EventHubs.EventHubClient.CreateFromConnectionString(builder.ToString());
return(AddEventHubCommandAuditing(resolver, client, partitionKeyProvider, options));
}
public void GenerateEvents()
{
var connectionStringBuilder = new EventHubsConnectionStringBuilder(eventHubConnectionString)
{
EntityPath = eventHubName
};
eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString());
SendMessagesToEventHub(100).GetAwaiter().GetResult();
eventHubClient.CloseAsync().GetAwaiter();
// ViewBag["Message"] = "Events Generated successfully";
}
private static async Task MainAsync()
{
var connection = new EventHubsConnectionStringBuilder(EventHubConnectionString)
{
EntityPath = EventHubName
};
eventHubClient = EventHubClient.CreateFromConnectionString(connection.ToString());
await SendMessageToHub();
await eventHubClient.CloseAsync();
Console.ReadLine();
}
private static async Task MainAsync(string[] args)
{
// Creates an EventHubsConnectionStringBuilder object from the connection string, and sets the EntityPath.
// Typically, the connection string should have the entity path in it, but for the sake of this simple scenario
// we are using the connection string from the namespace.
var connectionStringBuilder = new EventHubsConnectionStringBuilder(EhConnectionString)
{
EntityPath = EhEntityPath
};
eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString());
await SendMessagesToEventHub(1);
await eventHubClient.CloseAsync();
}
private static async Task MainAsync()
{
string EventHubConnectionString = Environment.GetEnvironmentVariable("EventHubConnectionString", EnvironmentVariableTarget.Machine);
string EventHubName = Environment.GetEnvironmentVariable("EventHubName", EnvironmentVariableTarget.Machine);
var connectionStringBuilder = new EventHubsConnectionStringBuilder(EventHubConnectionString)
{
EntityPath = EventHubName
};
eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString());
await SendMessagesToEventHub(100);
await eventHubClient.CloseAsync();
}
/// <summary>
/// Attempts to build an Azure Event Hubs connections string from the component parts defined
/// in this <see cref="AzureEventHubsLoggerOptions"/> instance.
/// </summary>
/// <param name="options"></param>
/// <param name="connectionString"></param>
/// <returns>True, if all parts are present and valid. Otherwise, false.</returns>
public static bool TryGetConnectionString(this AzureEventHubsLoggerOptions options, out string connectionString)
{
try
{
var builder = new EventHubsConnectionStringBuilder(options.Endpoint, options.EntityPath, options.SharedAccessKeyName, options.SharedAccessKey);
connectionString = builder.ToString();
return(true);
}
catch
{
connectionString = null;
return(false);
}
}
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestMessage req, TraceWriter log)
{
var connectionStringBuilder = new EventHubsConnectionStringBuilder(EhConnectionString)
{
EntityPath = EhEntityPath
};
eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString());
log.Info("C# HTTP trigger function processed a request.");
return(new HttpResponseMessage {
StatusCode = HttpStatusCode.OK
});
}
public static async void Run()
{
_masterDb = Database.GetDatabase("master");
var hubs = HubRepository.GetHubs(_masterDb);
var hubIds = hubs.Select(p => p.ID);
var hubsToAdd = hubs.Where(p => !HubTokens.ContainsKey(p.ID)).ToList();
var hubIdsToRemove = HubTokens.Select(p => p.Key).Where(p => !hubIds.Contains(p)).ToList();
// Remove loops that are not necessary anymore
foreach (var id in hubIdsToRemove)
{
if (!HubTokens.ContainsKey(id))
{
continue;
}
foreach (var token in HubTokens[id])
{
token.Cancel();
}
}
// Create hub loops
foreach (var hub in hubsToAdd)
{
// Create an EventHubClient instance to connect to the IoT Hub Event Hubs-compatible endpoint.
var connectionString = new EventHubsConnectionStringBuilder(new Uri(hub.EventHubscompatibleEndpoint),
hub.EventHubscompatiblePath, IotHubSasKeyName, hub.ServicePrimaryKey);
var eventHubClient = EventHubClient.CreateFromConnectionString(connectionString.ToString());
var tokens = new List <CancellationTokenSource>();
HubTokens.Add(hub.ID, tokens);
var runtimeInfo = await eventHubClient.GetRuntimeInformationAsync();
var d2CPartitions = runtimeInfo.PartitionIds;
var tasks = new List <Task>();
foreach (var partition in d2CPartitions)
{
var cts = new CancellationTokenSource();
tokens.Add(cts);
tasks.Add(ReceiveMessagesFromDeviceAsync(eventHubClient, partition, cts.Token));
}
// Wait for all the PartitionReceivers to finish.
Task.WaitAll(tasks.ToArray());
}
}
/// <summary>
/// Gets (instantiates) the <see cref="EventProcessorHost"/> for the specified <paramref name="eventHub"/> and <paramref name="consumerGroup"/>.
/// </summary>
/// <param name="config">The <see cref="IConfiguration"/>.</param>
/// <param name="eventHub">The event hub name.</param>
/// <param name="consumerGroup">The consumer group.</param>
/// <returns>The <see cref="EventProcessorHost"/>.</returns>
public EventProcessorHost GetEventProcessorHost(IConfiguration config, string eventHub, string consumerGroup)
{
if (!_eventHubs.TryGetValue(eventHub, out string connectionString))
{
throw new InvalidOperationException($"The specified Event Hub '{eventHub}' does not exist.");
}
// Build the storage connection string.
var storageConnectionString = config.GetWebJobsConnectionString(ConnectionStringNames.Storage);
EventHubsConnectionStringBuilder cs = new EventHubsConnectionStringBuilder(connectionString);
if (cs.EntityPath != null)
{
eventHub = cs.EntityPath;
cs.EntityPath = null;
}
EventHubPath = EscapeBlobPath(cs.Endpoint.Host);
EventHubName = EscapeBlobPath(eventHub);
var blobPrefix = $"{EventHubPath}/{EventHubName}/";
var maxRetryMinutes = config.GetValue <int>("MaxRetryMinutes");
if (maxRetryMinutes > 0 && maxRetryMinutes <= 60 * 24)
{
MaxRetryTimespan = TimeSpan.FromMinutes(maxRetryMinutes);
}
var logPoisonCount = config.GetValue <int>("LogPoisonMessageAfterRetryCount");
if (logPoisonCount > 0 && logPoisonCount <= 10)
{
LogPoisonMessageAfterRetryCount = logPoisonCount;
}
return(new EventProcessorHost(
hostName: Guid.NewGuid().ToString(),
eventHubPath: eventHub,
consumerGroupName: consumerGroup,
eventHubConnectionString: cs.ToString(),
storageConnectionString: storageConnectionString,
leaseContainerName: "azure-webjobs-eventhub",
storageBlobPrefix: blobPrefix)
{
PartitionManagerOptions = PartitionManagerOptions
});
}
/// <summary>
/// Iterates through the customers and populates their data into SQL
/// </summary>
public async Task PopulateRecentRateAndUsageInformation(CustomerContainer container)
{
var connectionStringBuilder = new EventHubsConnectionStringBuilder(_eventConnectionString)
{
EntityPath = _eventHubName
};
var eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString());
var now = DateTime.UtcNow;
//Set the sart and end dates to pull data into the db
var lastUpdateReportedStart = DateTime.UtcNow.Subtract(TimeSpan.FromHours(6));
var reportEndDate = DateTime.UtcNow.Subtract(TimeSpan.FromHours(5));
var usage = new AzureUsage(container);
var rates =
await usage.GetCombinedRatesAndUsage(lastUpdateReportedStart, reportEndDate, container.OfferId);
int index = 0;
int count = rates.Value.Count;
var customerDatas = new List <CustomerData>();
foreach (var rate in rates.Value)
{
string jsonOut = JsonConvert.SerializeObject(new CustomerData()
{
Category = rate.Properties.MeterCategory,
MeterId = rate.Properties.MeterId,
Price = rate.Properties.Price,
Cost = rate.Properties.Cost,
Unit = rate.Properties.Unit,
Quantity = rate.Properties.Quantity,
MeterName = rate.Properties.MeterName,
StartTime = DateTime.Parse(rate.Properties.UsageStartTime),
EndTime = DateTime.Parse(rate.Properties.UsageEndTime),
SubscriptionId = container.SubscriptionId,
ResourceGroup = rate.Properties.ResourceGroup,
ReportedStartDate = rates.ReportedStartDate,
ReportedEndDate = rates.ReportedEndData,
ResourceProvider = rate.Properties.ResourceProvider,
ResourceName = rate.Properties.ResourceName,
ResourceInstanceName = rate.Properties.ResourceSubName,
Tags = rate.Properties.Tags,
Location = rate.Properties.Location
});
await eventHubClient.SendAsync(new EventData(Encoding.UTF8.GetBytes(jsonOut)));
Console.WriteLine($"Adding record {++index} of {count} ");
}
await eventHubClient.CloseAsync();
}
private static async Task MainAsync(string[] args)
{
#region STRING/AZURE SETUP
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json");
var configuration = builder.Build();
var connectionStringBuilder = new EventHubsConnectionStringBuilder(configuration.GetSection("ConnectionStrings:DesktopTrackerHub").Value)
{
EntityPath = configuration.GetSection("DesktopTrackerEventHub:CloseMessage").Value
};
eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString());
#endregion
AutoResetEvent autoEvent = new AutoResetEvent(false);
Console.WriteLine("Checking Active Windows at: {0:h:mm:ss.fff} \n",
DateTime.UtcNow);
#region WINDOW TIMER
//Enter null for no break clause, e.g. program goes on forever
ActiveChecker activeWindows = new ActiveChecker(null);
//1000 = 1 second etc.
Timer foregroundTimer = new Timer(activeWindows.CheckWindows, autoEvent, 0, 5000);
#endregion
#region HIBERNATE TIMER
//Enter max time for Kiosk to hibernate
DateTime maxTimeForHibernate = DateTime.UtcNow.AddMinutes(30);
HibernateChecker hibernateChecker = new HibernateChecker(maxTimeForHibernate);
//Checks silently every 0.25 seconds
Timer hibernateTimer = new Timer(hibernateChecker.CheckHibernate, autoEvent, 0, 250);
#endregion
#if DEBUG
//Keeps console open
Console.ReadLine();
#endif
}
private static async Task Main(string[] args)
{
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json");
Configuration = builder.Build();
Console.WriteLine("IoT Hub Monitor - Read device to cloud messages. Ctrl-C to exit.\n");
// Create an EventHubClient instance to connect to the
// IoT Hub Event Hubs-compatible endpoint.
var hubConnectionString = new EventHubsConnectionStringBuilder(new Uri(Configuration[EventHubEndpointSetting]), Configuration[EventHubCompatibleNameSetting], Configuration[SasKeyNameSetting], Configuration[SasKeySetting]);
_eventHubClient = EventHubClient.CreateFromConnectionString(hubConnectionString.ToString());
// Create a PartitionReciever for each partition on the hub.
var hubRuntimeInfo = await _eventHubClient.GetRuntimeInformationAsync();
List <Tuple <EventHubClient, string> > d2CPartitions =
hubRuntimeInfo.PartitionIds
.Select(id => new Tuple <EventHubClient, string>(_eventHubClient, id))
.ToList();
CancellationTokenSource cts = new CancellationTokenSource();
Console.CancelKeyPress += (s, e) =>
{
e.Cancel = true;
cts.Cancel();
Console.WriteLine("Exiting...");
};
var tasks = new List <Task>();
foreach (Tuple <EventHubClient, string> eventHubClientPartitionPair in d2CPartitions)
{
tasks.Add(ReceiveMessagesFromDeviceAsync(eventHubClientPartitionPair.Item1, eventHubClientPartitionPair.Item2, cts.Token));
}
if (Configuration[SimulateEventsSetting] == "true")
{
tasks.Add(SimulateEvents(cts.Token));
}
// Wait for all the PartitionReceivers to finish.
Task.WaitAll(tasks.ToArray());
}
