public override bool OnStart()
{
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
bool result = base.OnStart();
Trace.TraceInformation("KAIT.PushNotificationService has been started");
string storage = "DefaultEndpointsProtocol=https;AccountName=inceptionasamonitoring;AccountKey=Lwtx59G+gypbFHrk0+DT8ggdk045CQBp/qXrlUlclVqOhTyIIo7u72DnnEhWzu6bgPtnJ948Ad4M2/gSWx7osw==";
string serviceBus = "Endpoint=sb://inceptioningess-ns.servicebus.windows.net/;SharedAccessKeyName=ListenPolicy;SharedAccessKey=jMkbgtpkPb9pwVTKLoIKhuKAgN6Q6BHHpf00kPQ2AxU=";
string eventHubName = "interactionsnotifications";
EventHubClient client = EventHubClient.CreateFromConnectionString(serviceBus, eventHubName);
Trace.TraceInformation("Consumer group is: " + client.GetDefaultConsumerGroup().GroupName);
_host = new EventProcessorHost("singleworker", eventHubName, client.GetDefaultConsumerGroup().GroupName, serviceBus, storage);
Trace.TraceInformation("Created event processor host...");
return(result);
}
private void ReceiveMessagesFromDevice(string partition, CancellationToken ct)
{
var eventHubReceiver = eventHubClient.GetDefaultConsumerGroup().CreateReceiver(partition, DateTime.Now.AddDays(-1));
//var eventHubReceiver = eventHubClient.GetConsumerGroup("webapp").CreateReceiver(partition, DateTime.Now.AddDays(-1));
int i = 0;
while (i < 4)
{
if (ct.IsCancellationRequested)
{
break;
}
EventData eventData = eventHubReceiver.Receive();
//if (eventData == null) continue;
if (eventData == null)
{
break;
}
string data = Encoding.UTF8.GetString(eventData.GetBytes());
/*MemoryStream stream1 = new MemoryStream(eventData.GetBytes());
* DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Sensor));
*
* stream1.Position = 0;
* Sensor sensor = (Sensor)ser.ReadObject(stream1);*/
JavaScriptSerializer json_serializer = new JavaScriptSerializer();
Sensor sensor = json_serializer.Deserialize <Sensor>(data);
db.Sensors.Add(sensor);
db.SaveChanges();
i++;
//Console.WriteLine("Message received. Partition: {0} Data: '{1}'", partition, data);
/*Sensor sensor = new Sensor (data.);
* db.Sensors.Add(sensor);
* db.SaveChanges();*/
}
eventHubReceiver.Close();
//return RedirectToAction("Index");
return;
}
private async static Task ReceiveMessagesFromDeviceAsync(string partition)
{
var eventHubReceiver = eventHubClient.GetDefaultConsumerGroup().CreateReceiver(partition, DateTime.UtcNow);
while (true)
{
EventData eventData = await eventHubReceiver.ReceiveAsync();
if (eventData == null)
{
continue;
}
string data = Encoding.UTF8.GetString(eventData.GetBytes());
evData d = JsonConvert.DeserializeObject <evData>(data);
StreamWriter writer = new StreamWriter("c:\\gps\\download\\"
+ d.id + "." + DateTime.Now.Year + "." + DateTime.Now.Month
+ "." + DateTime.Now.Day + "." + DateTime.Now.Hour + "."
+ DateTime.Now.Minute + "." + DateTime.Now.Second + ".csv");
writer.Write(d.data);
writer.Close();
Console.WriteLine(string.Format("Message received from {0}.\n{1}", d.id, d.data));
}
}
public override bool OnStart()
{
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
bool result = base.OnStart();
Trace.TraceInformation("EventsForwarding OnStart()...\n");
connectionString = ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"];
eventHubName = ConfigurationManager.AppSettings["Microsoft.ServiceBus.EventHubName"];
string storageAccountName = ConfigurationManager.AppSettings["AzureStorage.AccountName"];
string storageAccountKey = ConfigurationManager.AppSettings["AzureStorage.Key"];
string storageAccountString = string.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}",
storageAccountName, storageAccountKey);
string iotHubConnectionString = ConfigurationManager.AppSettings["AzureIoTHub.ConnectionString"];
iotHubServiceClient = ServiceClient.CreateFromConnectionString(iotHubConnectionString);
eventHubClient = EventHubClient.CreateFromConnectionString(connectionString, eventHubName);
var defaultConsumerGroup = eventHubClient.GetDefaultConsumerGroup();
string eventProcessorHostName = "SensorEventProcessor";
EventProcessorHost eventProcessorHost = new EventProcessorHost(eventProcessorHostName, eventHubName, defaultConsumerGroup.GroupName, connectionString, storageAccountString);
eventProcessorHost.RegisterEventProcessorAsync<SensorEventProcessor>().Wait();
Trace.TraceInformation("Receiving events...\n");
return result;
}
/// <summary>
/// Receive Messages from device. By default if reads partition 0 but you can specifiy the partition
/// </summary>
/// <param name="partition"></param>
/// <returns></returns>
public static async Task <EventData> ReceiveMessagesFromDeviceAsync(string partition = "0")
{
try
{
// If you are running this from a client you are likely to have to open up ports on the client
// firewall of specifiy HTTP for transport
//ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.Http;
// get all messages
var eventHubReceiver = eventHubClient.GetDefaultConsumerGroup().CreateReceiver(partition,
DateTime.UtcNow.Subtract(new TimeSpan(1, 0, 0)));
EventData eventData = await eventHubReceiver.ReceiveAsync();
if (eventData != null)
{
string data = Encoding.UTF8.GetString(eventData.GetBytes());
Console.WriteLine("Message received. Partition: {0} Data: '{1}'", partition, data);
}
return(eventData);
}
catch (Exception ex)
{
Console.WriteLine($"{Utils.FormatExceptionMessage(ex)}");
throw ex;
}
}
static void PrintMessages(string partitionId, long offset, int numberOfEvents)
{
EventHubReceiver receiver;
try
{
receiver = eventHubClient.GetDefaultConsumerGroup().CreateReceiver(partitionId, offset.ToString(), true);
}
catch (ArgumentException)
{
Console.WriteLine("No data for the specified offset in this partition.");
return;
}
try
{
foreach (var e in receiver.Receive(numberOfEvents, TimeSpan.FromMinutes(1)))
{
Console.WriteLine(Encoding.UTF8.GetString(e.GetBytes()));
Console.WriteLine("----");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
return;
}
receiver.Close();
}
static void Main(string[] args)
{
string ehname = "<eventhubname>";
string connection = "Endpoint=sb://<eventhubnamespace>.servicebus.windows.net/;SharedAccessKeyName=<policy>;SharedAccessKey=<key>;TransportType=Amqp";
MessagingFactory factory = MessagingFactory.CreateFromConnectionString(connection);
EventHubClient ehub = factory.CreateEventHubClient(ehname);
EventHubConsumerGroup group = ehub.GetDefaultConsumerGroup();
EventHubReceiver reciever = group.CreateReceiver("0");
while (true)
{
EventData data = reciever.Receive();
if (data != null)
{
try
{
string message = Encoding.UTF8.GetString(data.GetBytes());
Console.WriteLine(message + " " + DateTime.Now);
Console.WriteLine();
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
}
}
static async Task Listen(string partitionId)
{
Console.WriteLine("Listening to partition " + partitionId);
// receive all events after UtcNow (replay events)
var receiver = await _eventHubClient.GetDefaultConsumerGroup().CreateReceiverAsync(partitionId, DateTime.UtcNow);
while (true)
{
// wait for a event to receive
var eventData = await receiver.ReceiveAsync();
if (eventData == null)
{
continue;
}
// read event data
var json = Encoding.ASCII.GetString(eventData.GetBytes());
var powerUsage = JsonConvert.DeserializeObject <PowerUsage>(json);
var deviceId = eventData.SystemProperties["iothub-connection-device-id"].ToString();
Console.WriteLine("Event received: " + json);
// post to signalr (notify web clients)
var signalrRequest = new DevicePowerUsage
{
Id = Guid.Parse(deviceId),
Value = powerUsage.Value
};
await HttpService.Post("api/deviceupdate", signalrRequest);
}
}
private async Task ReceiveMessagesFromDeviceAsync(string partition, CancellationToken ct)
{
var eventHubReceiver = eventHubClient.GetDefaultConsumerGroup().CreateReceiver(partition, DateTime.UtcNow);
while (true)
{
if (ct.IsCancellationRequested)
{
break;
}
EventData eventData = await eventHubReceiver.ReceiveAsync();
if (eventData == null)
{
continue;
}
var data = Encoding.UTF8.GetString(eventData.GetBytes());
Debug.WriteLine("Message received. Partition: {0} Data: '{1}'", partition, data);
var temperature = JsonConvert.DeserializeObject <TemperatureData>(data);
temperature.PartitionId = partition;
var hub = new TemperatureHub();
await hub.NotifyClient(temperature);
}
}
private static void EventHubReceive()
{
var ehName = "davnaeventhub";
var connection = "Endpoint=sb://alewife.servicebus.windows.net/;SharedAccessKeyName=Receiver;SharedAccessKey=3jaTeykwRu84x93OpW3DftRO1WSHt4oi7QB0FRyHoyg=;TransportType=Amqp";
MessagingFactory factory = MessagingFactory.CreateFromConnectionString(connection);
EventHubClient ehub = factory.CreateEventHubClient(ehName);
EventHubConsumerGroup group = ehub.GetDefaultConsumerGroup();
EventHubReceiver receiver = group.CreateReceiver("1");
while (true)
{
EventData data = receiver.Receive();
if (data != null)
{
var message = Encoding.UTF8.GetString(data.GetBytes());
Console.WriteLine("PartitionKey: {0}", data.PartitionKey);
Console.WriteLine("SequenceNumber: {0}", data.SequenceNumber);
Console.WriteLine(message);
}
}
}
private static async Task ReceiveMessagesFromDeviceAsync(string partition, CancellationToken ct)
{
var min = Convert.ToInt32(ConfigurationManager.AppSettings["minutes"]);
var dte = DateTime.UtcNow.AddMinutes(min);
var eventHubReceiver = eventHubClient.GetDefaultConsumerGroup().CreateReceiver(partition, dte);
while (true)
{
if (ct.IsCancellationRequested)
{
break;
}
EventData eventData = await eventHubReceiver.ReceiveAsync();
if (eventData == null)
{
continue;
}
string data = Encoding.UTF8.GetString(eventData.GetBytes());
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Message received => Partition: {0}, Data: '{1}'", partition, data);
Console.ResetColor();
SendMessagesToRestApi(data);
}
}
//code adapted from tutorial https://paolopatierno.wordpress.com/2015/11/02/azure-iot-hub-get-telemetry-data-using-amqp-stack-and-azure-sb-lite/
public static string GetMessage(string partitionId)
{
string result = null;
ServiceBusConnectionStringBuilder builder = new ServiceBusConnectionStringBuilder(ConnectionString);
builder.TransportType = TransportType.Amqp;
MessagingFactory factory = MessagingFactory.CreateFromConnectionString(ConnectionString);
EventHubClient client = factory.CreateEventHubClient(eventHubEntity);
EventHubConsumerGroup group = client.GetDefaultConsumerGroup();
var startingDateTimeUtc = DateTime.Now;
EventHubReceiver receiver = group.CreateReceiver(partitionId, startingDateTimeUtc);
EventData data = receiver.Receive();
receiver.Close();
client.Close();
factory.Close();
if (data != null)
{
result = Encoding.UTF8.GetString(data.GetBytes());
return(result);
}
else
{
return(null);
}
}
private async Task ReceiveMessagesFromDeviceAsync(string partition, CancellationToken ct)
{
try
{
processData("internal", $"Start listening to Partition: {partition}");
var eventHubReceiver = EventHubClient.GetDefaultConsumerGroup().CreateReceiver(partition, DateTime.UtcNow);
while (true)
{
if (ct.IsCancellationRequested)
{
break;
}
EventData eventData = await eventHubReceiver.ReceiveAsync();
if (eventData == null)
{
continue;
}
string data = Encoding.UTF8.GetString(eventData.GetBytes());
string device = eventData.SystemProperties.ContainsKey("iothub-connection-device-id")
? eventData.SystemProperties["iothub-connection-device-id"].ToString().Trim()
: null;
Debug.WriteLine("Message received. Partition: {0} Data: '{1}'", partition, data);
processData(device, data);
}
Debug.WriteLine("Cancel Receiver task");
}
catch (Exception ex)
{
processData("internal - exception", ex.ToString());
}
}
static void Main(string[] args)
{
string ehname = "<eventhubname>";
string connection = "<eventhubconnectionstring>,TransportType=Amqp";
MessagingFactory factory = MessagingFactory.CreateFromConnectionString(connection);
EventHubClient ehub = factory.CreateEventHubClient(ehname);
EventHubConsumerGroup group = ehub.GetDefaultConsumerGroup();
EventHubReceiver reciever = group.CreateReceiver("0");
while (true)
{
EventData data = reciever.Receive();
if (data != null)
{
try
{
string message = Encoding.UTF8.GetString(data.GetBytes());
//Console.WriteLine("Partition Key: {0}", data.PartitionKey);
Console.WriteLine(message);
Console.WriteLine();
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
}
}
public async Task<string> OpenAsync(CancellationToken cancellationToken)
{
var builder = new ServiceBusConnectionStringBuilder(_connectionString)
{
TransportType = TransportType.Amqp
};
_messagingFactory = MessagingFactory.CreateFromConnectionString(builder.ToString());
_eventHubClient = _messagingFactory.CreateEventHubClient(_eventHubName);
_consumerGroup = !string.IsNullOrEmpty(_consumerGroupName)
? _eventHubClient.GetConsumerGroup(_consumerGroupName)
: _eventHubClient.GetDefaultConsumerGroup();
_eventProcessorFactory = new EventProcessorFactory();
_leaseRepository = new ReliableStateLeaseRepository(_reliableStateManager);
_checkpointManager = new CheckpointManager(_leaseRepository);
var allocatedPartitions = await new EventHubPartitionPartitionAllocationStrategy(_serviceName, _partitionId)
.AllocateAsync(_eventHubClient, new FabricClient());
foreach (var partition in allocatedPartitions)
{
var lease = await _leaseRepository.GetOrCreateAsync(_connectionString, _consumerGroupName, _eventHubName, partition);
await _consumerGroup.RegisterProcessorFactoryAsync(lease, _checkpointManager, _eventProcessorFactory);
}
return string.Concat(_eventHubName, " @ ", _connectionString);
}
private async Task ReceiveMessagesFromDeviceAsync(string partition)
{
var eventHubReceiver = eventHubClient.GetDefaultConsumerGroup().CreateReceiver(partition, DateTime.Now);
while (true)
{
EventData eventData = await eventHubReceiver.ReceiveAsync();
if (eventData == null)
{
continue;
}
string data = Encoding.UTF8.GetString(eventData.GetBytes());
Console.WriteLine(string.Format("Message received. Partition: {0} Data: '{1}'", partition, data));
WeatherRecord record = JsonConvert.DeserializeObject <WeatherRecord>(data);
try
{
WriteToTable(record);
}
catch (Exception ex)
{
ex = ex;
}
}
}
public override void Run()
{
string eventHubConnectionString = System.Configuration.ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"];
string blobConnectionString = System.Configuration.ConfigurationManager.AppSettings["AzureStorageConnectionString"];
string workerName = RoleEnvironment.CurrentRoleInstance.Role.Name;
string eventHubName = System.Configuration.ConfigurationManager.AppSettings["EventHubName"];
// Event Hub client
EventHubClient eventHubClient = EventHubClient.CreateFromConnectionString(eventHubConnectionString, eventHubName);
// Default Consumer Group
EventHubConsumerGroup defaultConsumerGroup = eventHubClient.GetDefaultConsumerGroup();
// Create the EventProcessorHost
host = new EventProcessorHost(workerName, eventHubName, defaultConsumerGroup.GroupName, eventHubConnectionString, blobConnectionString);
// Register our event processor
host.RegisterEventProcessorAsync <SimpleEventProcessor>();
// Wait forever
while (true)
{
Task.Delay(60 * 1000);
}
}
private async Task ReceiveMessagesFromDeviceAsync(string partition, CancellationToken ct)
{
var eventHubReceiver = eventHubClient.GetDefaultConsumerGroup().CreateReceiver(partition, DateTime.UtcNow);
while (true)
{
if (ct.IsCancellationRequested)
{
break;
}
EventData eventData = await eventHubReceiver.ReceiveAsync();
if (eventData == null)
{
continue;
}
string data = Encoding.UTF8.GetString(eventData.GetBytes());
IOTMessageFormat message = JsonConvert.DeserializeObject <IOTMessageFormat>(data);
// bool isAlert = Convert.ToBoolean(eventData.Properties["waterAlert"]);
if (message.isDry && notificationSentCount < 5)
{
MyNotification.SendFireBaseNotification(configs.FireBaseConnectionString, message.message);
notificationSentCount++;
}
else
{
MyNotification.SendFireBaseNotification(configs.FireBaseConnectionString, message.message);
}
Console.WriteLine("Message received. Partition: {0} Data: '{1}'", partition, data);
}
}
public async void ReadUsingEventHubProcessor()
{
string serviceBusNamespace = "iotmc-ns";
string eventHubName = "iotmc";
string eventHubSASKeyName = "Device01";
string eventHubSASKey = "<< Add your SAS here >>";
string storageAccountName = "iotmc";
string storageAccountKey = "<< add your Storage Account key here >>";
string storageConnectionString = String.Format(@"DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}", storageAccountName, storageAccountKey);
string eventHubConnectionString = ServiceBusConnectionStringBuilder.CreateUsingSharedAccessKey(
ServiceBusEnvironment.CreateServiceUri("sb", serviceBusNamespace, string.Empty),
eventHubSASKeyName,
eventHubSASKey);
EventHubClient eventHubClient = EventHubClient.CreateFromConnectionString(eventHubConnectionString, eventHubName);
EventHubConsumerGroup eventHubConsumerGroup = eventHubClient.GetDefaultConsumerGroup();
EventProcessorHost eventProcessorHost = new EventProcessorHost("MSTechDemoWorker", eventHubClient.Path, eventHubConsumerGroup.GroupName, eventHubConnectionString, storageConnectionString);
//await eventProcessorHost.RegisterEventProcessorAsync<EventHubEventProcessor>();
//Ignore older messages even if they are still in the event hub store
Task t = eventProcessorHost.RegisterEventProcessorAsync <EventHubEventProcessor>(new EventProcessorOptions()
{
InitialOffsetProvider = (partitionId) => { return(DateTime.UtcNow.AddHours(-1)); }
});
t.Wait();
}
private static async Task ReceiveMessagesFromDeviceAsync(string partition, CancellationToken ct)
{
var eventHubReceiver = eventHubClient.GetDefaultConsumerGroup().CreateReceiver(partition, DateTime.UtcNow);
while (true)
{
if (ct.IsCancellationRequested)
{
break;
}
EventData eventData = await eventHubReceiver.ReceiveAsync(TimeSpan.FromSeconds(2));
if (eventData == null)
{
continue;
}
var deviceId = eventData.SystemProperties["iothub-connection-device-id"] as string;
deviceId = deviceId.Substring("dispositivo".Length);
string data = Encoding.UTF8.GetString(eventData.GetBytes());
Debug.WriteLine("Message received. Partition: {0} Data: '{1}'", partition, data);
var telemetria = JsonConvert.DeserializeObject <Telemetria>(data);
telemetria.IdDispositivo = int.Parse(deviceId);
TelemetriaHub.InviaMessaggio(telemetria);
}
}
private static async Task ReceiveMessagesFromDeviceAsync(string partition, CancellationToken ct)
{
var eventHubReceiver = eventHubClient.GetDefaultConsumerGroup().CreateReceiver(partition, DateTime.UtcNow);
while (true)
{
if (ct.IsCancellationRequested)
{
break;
}
EventData eventData = await eventHubReceiver.ReceiveAsync();
if (eventData == null)
{
return;
}
string data = Encoding.UTF8.GetString(eventData.GetBytes());
BaseMessage msg = MessageHelper.ToObject(data);
if (msg != null)
{
msgReceiveQueue.Enqueue(msg);
}
}
}
private async static Task ReceiveMessagesFromMonitorAsync(string partition)
{
var eventHubReceiver = operHubClient.GetDefaultConsumerGroup().CreateReceiver(partition, DateTime.Now);
while (true)
{
EventData eventData = null;
try
{
eventData = await eventHubReceiver.ReceiveAsync();
Trace.TraceInformation("RAW MONITOR RECEIVED:{1}: {0}", Encoding.UTF8.GetString(eventData.GetBytes()), DateTime.Now);
Console.WriteLine("RAW MONITOR RECEIVED:{1}: {0}", Encoding.UTF8.GetString(eventData.GetBytes()), DateTime.Now);
}
catch (Exception e)
{
Trace.TraceWarning("{0}:TIMEOUT at MONITOR occurred", DateTime.Now);
Console.WriteLine("{0}:TIMEOUT at MONITOR occurred", DateTime.Now);
}
if (eventData == null)
{
continue;
}
IoTHubMessage msg = new IoTHubMessage();
msg.enqueuedTime = eventData.EnqueuedTimeUtc;
msg.message = Encoding.UTF8.GetString(eventData.GetBytes());
//Trace.TraceInformation("RECEIVED: {0}", msg.message);
//Console.WriteLine("RECEIVED: {0}", msg.message);
ProcessMonitorMessageAsync(msg);
}
}
public async Task ReceiveDataFromCloud()
{
startingDateTimeUtc = DateTime.UtcNow - TimeSpan.FromHours(24);
factory = MessagingFactory.CreateFromConnectionString(ConnectionString);
client = factory.CreateEventHubClient(eventHubEntity);
group = client.GetDefaultConsumerGroup();
receiver = group.CreateReceiver(partitionId.ToString(), startingDateTimeUtc);
try
{
while (true)
{
EventData data = receiver.Receive();
if (data != null)
{
var receiveddata = Encoding.UTF8.GetString(data.GetBytes());
Debug.WriteLine("{0} {1} {2}", data.SequenceNumber, data.EnqueuedTimeUtc.ToLocalTime(), receiveddata);
}
}
}
catch (Exception ex)
{
Debug.WriteLine("Exception {0}", ex);
}
receiver.Close();
client.Close();
factory.Close();
}
private static async Task ReceiveMessagesFromDeviceAsync(string partition, CancellationToken ct)
{
TimeZone localTimeZone = TimeZone.CurrentTimeZone;
DateTime startDateTimeUtc = DateTimeOffset.Parse(startDateTime).UtcDateTime;
DateTime currentUTC = DateTime.UtcNow;
var eventHubReceiver = eventHubClient.GetDefaultConsumerGroup().CreateReceiver(partition, startDateTimeUtc);
while (true)
{
if (ct.IsCancellationRequested)
{
break;
}
EventData eventData = await eventHubReceiver.ReceiveAsync();
if (eventData == null)
{
continue;
}
string data = Encoding.UTF8.GetString(eventData.GetBytes());
Console.WriteLine("Message received. Partition: {0} Data: '{1}'", partition, data);
}
}
static int Main(string[] args)
{
if (args.Length == 0)
{
Console.WriteLine("Proton-DotNet.exe connection_string");
return(2);
}
try
{
EventHubClient ehc = EventHubClient.CreateFromConnectionString(args[0]);
EventHubReceiver receiver = ehc.GetDefaultConsumerGroup().CreateReceiver("0");
while (true)
{
EventData data = receiver.Receive();
if (data == null)
{
break;
}
string text = Encoding.UTF8.GetString(data.GetBytes());
Console.WriteLine(data.SequenceNumber + ":" + text);
}
ehc.Close();
return(0);
}
catch (Exception exception)
{
Console.WriteLine(exception.ToString());
}
return(1);
}
private async static Task ReceiveMessagesFromDeviceAsync(CancellationToken cancellationToken, string partition)
{
var eventHubReceiver = eventHubClient.GetDefaultConsumerGroup().CreateReceiver(partition, DateTime.UtcNow);
while (!cancellationToken.IsCancellationRequested)
{
EventData eventData = await eventHubReceiver.ReceiveAsync();
if (eventData == null)
{
continue;
}
string data = Encoding.UTF8.GetString(eventData.GetBytes());
Console.WriteLine(string.Format("Message received. Partition: {0} Data: '{1}'", partition, data));
dynamic dataObject = JsonConvert.DeserializeObject(data);
Console.WriteLine(string.Format("Throttle received: {0}", dataObject.throttle));
if (dataObject.throttle > MAX_THROTTLE)
{
Console.WriteLine("throttle over " + MAX_THROTTLE);
SendCloudToDeviceMessageAsync().Wait();
}
}
}
public void MessageProcessingWithPartitionDistribution(ConsumerGroupDescription group)
{
EventHubClient eventHubClient = EventHubClient.CreateFromConnectionString(eventHubConnectionString, this.eventHubName);
// Get the default Consumer Group
//defaultConsumerGroup = eventHubClient.GetDefaultConsumerGroup();
string blobConnectionString = ConfigurationManager.AppSettings["AzureStorageConnectionString"]; // Required for checkpoint/state
if (null == group)
{
//Use default consumer group
EventHubConsumerGroup defaultConsumerGroup = eventHubClient.GetDefaultConsumerGroup();
eventProcessorHost = new EventProcessorHost("singleworker", eventHubClient.Path, defaultConsumerGroup.GroupName, this.eventHubConnectionString, blobConnectionString);
}
else
{
//Use custom consumer group
eventProcessorHost = new EventProcessorHost("singleworker", eventHubClient.Path, group.Name, this.eventHubConnectionString, blobConnectionString);
}
//Only use events from the time the sender is started.
EventProcessorOptions options = new EventProcessorOptions();
options.InitialOffsetProvider = (partitionId) => DateTime.UtcNow;
eventProcessorHost.RegisterEventProcessorAsync <SimpleEventProcessor>(options).Wait();
}
private static async Task ReceiveMessagesFromDeviceAsync(string partition, CancellationToken ct)
{
var eventHubReceiver = eventHubClient.GetDefaultConsumerGroup().CreateReceiver(partition, DateTime.UtcNow);
while (true)
{
if (ct.IsCancellationRequested) break;
EventData eventData = await eventHubReceiver.ReceiveAsync();
if (eventData == null) continue;
var sensorData = eventData.GetBytes();
// this is how to calculate the temperature according to the TI docs
//var ambientTemp = calculator.CalculateAmbientTemperature(sensorData, temperatureScale);
//var targetTemp = calculator.CalculateTargetTemperature(sensorData, ambientTemp, temperatureScale);
//Console.WriteLine($"Partion {partition} - {targetTemp}, {ambientTemp}");
// this is how the Azure IoT Hub Gateway module ble_printer does it
double ambient = 0, target = 0;
sensortag_temp_convert(BitConverter.ToUInt16(sensorData, 2), BitConverter.ToUInt16(sensorData, 0), ref ambient, ref target);
Console.WriteLine($"Partion {partition} - {target}, {ambient}");
}
}
static void Main(string[] args)
{
// Start a worker that consumes messages from the event hub.
EventHubClient eventHubReceiveClient = EventHubClient.CreateFromConnectionString(GetAmqpConnectionString(), eventHubName);
var subscriberGroup = eventHubReceiveClient.GetDefaultConsumerGroup();
EventHubDescription eventHub = NamespaceManager.CreateFromConnectionString(GetAmqpConnectionString()).GetEventHub(eventHubName);
// Register event processor with each shard to start consuming messages
List <Worker> allWorkers = new List <Worker>();
foreach (var partitionId in eventHub.PartitionIds)
{
Worker temp = new Worker(subscriberGroup, partitionId);
allWorkers.Add(temp);
}
// Wait for the user to exit this application.
Console.WriteLine("\nPress ENTER to exit...\n");
Console.ReadLine();
foreach (var w in allWorkers)
{
w.RequestStop();
}
}
//------------------------------------------------------------------------------------------------------------------------
#endregion
#region Constructor
//------------------------------------------------------------------------------------------------------------------------
public EventHubDirectConsumer(EventHubClient client)
{
//create event hub direct consumer
EventHubConsumerGroup group = client.GetDefaultConsumerGroup();
var x = client.GetRuntimeInformation().PartitionIds[0];
eventHubDirectReceiver = group.CreateReceiver(client.GetRuntimeInformation().PartitionIds[0]);
}
//------------------------------------------------------------------------------------------------------------------------
#endregion
#region Constructor
//------------------------------------------------------------------------------------------------------------------------
public EventHubDirectConsumer(EventHubClient client)
{
//create event hub direct consumer
EventHubConsumerGroup group = client.GetDefaultConsumerGroup();
var x = client.GetRuntimeInformation().PartitionIds[0];
eventHubDirectReceiver = group.CreateReceiver(client.GetRuntimeInformation().PartitionIds[0]);
}
public async Task ReadAllAsync(DateTime startTime)
{
PrepareToRead();
try {
foreach (var p in _partitions)
{
var rcv = await _client.GetDefaultConsumerGroup().CreateReceiverAsync(p.PartitionId, startTime.ToUniversalTime());
_runningTasks.Add(p.ReadAsync(rcv, _cancellation));
}
}
catch (OperationCanceledException ex)
{
Debug.WriteLine("tasks cancelled");
}
}
public void MessageProcessingWithPartitionDistribution()
{
EventHubClient eventHubClient = EventHubClient.CreateFromConnectionString(eventHubConnectionString, this.eventHubName);
// Get the default Consumer Group
defaultConsumerGroup = eventHubClient.GetDefaultConsumerGroup();
string blobConnectionString = ConfigurationManager.AppSettings["AzureStorageConnectionString"]; // Required for checkpoint/state
eventProcessorHost = new EventProcessorHost("singleworker", eventHubClient.Path, defaultConsumerGroup.GroupName, this.eventHubConnectionString, blobConnectionString);
eventProcessorHost.RegisterEventProcessorAsync <SimpleEventProcessor>().Wait();
}
public async void ProcessEvents()
{
eventHubName = "azureguidanceevnthub";
connectionString = GetServiceBusConnectionString();
NamespaceManager namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
eventHubClient = EventHubClient.CreateFromConnectionString(connectionString, eventHubName);
defaultConsumerGroup = eventHubClient.GetDefaultConsumerGroup();
string blobConnectionString = ConfigurationManager.AppSettings["AzureStorageConnectionString"]; // Required for checkpoint/state
eventProcessorHost = new EventProcessorHost("AzureGuidanceReceiver", eventHubClient.Path, defaultConsumerGroup.GroupName, connectionString, blobConnectionString);
await eventProcessorHost.RegisterEventProcessorAsync<SimpleEventProcessor>();
}
public Task InitializeEventProcessor(string connectionString, string eventHubName, string storageConnectionString, string path, string cGroup = null, string vin = null, string activityId = null)
{
Filter.BlockingCollection = new BlockingCollection<string>(int.MaxValue);
Filter.EventDataCollection = new BlockingCollection<EventData>(int.MaxValue);
Filter.Path = path;
Filter.Vin = vin;
Filter.ActivityId = activityId;
this.eventHubClient = EventHubClient.CreateFromConnectionString(connectionString, eventHubName);
this.consumerGroup = string.IsNullOrWhiteSpace(cGroup)
? eventHubClient.GetDefaultConsumerGroup()
: eventHubClient.GetConsumerGroup(cGroup);
this.eventProcessorHost = new EventProcessorHost("EventHubReader", eventHubClient.Path, this.consumerGroup.GroupName, connectionString, storageConnectionString);
return this.eventProcessorHost.RegisterEventProcessorAsync<EventProcessor>();
}
public PartitionListenerControl(WriteToLogDelegate writeToLog,
Func<Task> stopLog,
Action startLog,
string iotHubConnectionString,
string consumerGroupName)
{
Task.Factory.StartNew(AsyncTrackEventData).ContinueWith(t =>
{
if (t.IsFaulted && t.Exception != null)
{
writeToLog(t.Exception.Message);
}
});
this.iotHubConnectionString = iotHubConnectionString;
this.writeToLog = writeToLog;
this.stopLog = stopLog;
this.startLog = startLog;
serviceBusHelper = new ServiceBusHelper(writeToLog);
eventHubClient = EventHubClient.CreateFromConnectionString(iotHubConnectionString, "messages/events");
consumerGroup = string.Compare(consumerGroupName,
DefaultConsumerGroupName,
StringComparison.InvariantCultureIgnoreCase) == 0
? eventHubClient.GetDefaultConsumerGroup()
: eventHubClient.GetConsumerGroup(consumerGroupName);
IList<string> partitionIdList = new List<string>(eventHubClient.GetRuntimeInformation().PartitionIds);
foreach (var id in partitionIdList)
{
partitionRuntumeInformationList.Add(eventHubClient.GetPartitionRuntimeInformation(id));
}
partitionCount = partitionRuntumeInformationList.Count;
InitializeComponent();
InitializeControls();
Disposed += ListenerControl_Disposed;
}
public PartitionListenerControl(WriteToLogDelegate writeToLog,
Func<Task> stopLog,
Action startLog,
ServiceBusHelper serviceBusHelper,
ConsumerGroupDescription consumerGroupDescription,
IEnumerable<PartitionDescription> partitionDescriptions)
{
Task.Factory.StartNew(AsyncTrackEventData).ContinueWith(t =>
{
if (t.IsFaulted && t.Exception != null)
{
writeToLog(t.Exception.Message);
}
});
this.writeToLog = writeToLog;
this.stopLog = stopLog;
this.startLog = startLog;
this.serviceBusHelper = serviceBusHelper;
eventHubDescription = serviceBusHelper.NamespaceManager.GetEventHub(consumerGroupDescription.EventHubPath);
eventHubClient = EventHubClient.CreateFromConnectionString(GetAmqpConnectionString(serviceBusHelper.ConnectionString),
consumerGroupDescription.EventHubPath);
consumerGroup = string.Compare(consumerGroupDescription.Name,
DefaultConsumerGroupName,
StringComparison.InvariantCultureIgnoreCase) == 0
? eventHubClient.GetDefaultConsumerGroup()
: eventHubClient.GetConsumerGroup(consumerGroupDescription.Name);
IList<string> partitionIdList = partitionDescriptions.Select(pd => pd.PartitionId).ToList();
foreach (var id in partitionIdList)
{
partitionRuntumeInformationList.Add(eventHubClient.GetPartitionRuntimeInformation(id));
}
partitionCount = partitionRuntumeInformationList.Count;
InitializeComponent();
InitializeControls();
Disposed += ListenerControl_Disposed;
}
public async Task<string> OpenAsync(CancellationToken cancellationToken)
{
await mOptions.PrepareAsync();
var useDefaultConsumerGroup = !string.IsNullOrEmpty(mOptions.EventHubConsumerGroupName);
mMessagingFactory = MessagingFactory.CreateFromConnectionString(mOptions.EventHubConnectionString);
mEventHubClient = mMessagingFactory.CreateEventHubClient(mOptions.EventHubName);
mConsumerGroup = useDefaultConsumerGroup ?
mEventHubClient.GetConsumerGroup(mOptions.EventHubConsumerGroupName)
: mEventHubClient.GetDefaultConsumerGroup();
return string.Concat(mEventHubNamespace, "/",
mOptions.EventHubName, "/",
useDefaultConsumerGroup ? "<default group>" : mOptions.EventHubConsumerGroupName);
}
