static void Main(string[] args)
{
string connectionString =
@"<eventhub connection string without EntityPath>";
NamespaceManager namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
string eventHubName = "lazhueventhub";
EventHubClient client = EventHubClient.Create(eventHubName);
int i = 0;
Random rand = new Random();
while (true)
{
CDRecord r = new CDRecord();
r.id = i;
r.temperature = 20.1;
r.humidity = 68.6;
r.createtime = DateTime.Now;
r.msgtype = "thsensor";
r.sensorID = new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa1, 0x01, 0xd1, 0x17 };
r.typeID = rand.Next() % 4;
var serializedString = JsonConvert.SerializeObject(r);
EventData data = new EventData(Encoding.UTF8.GetBytes(serializedString));
client.Send(data);
Console.WriteLine("Send " + i + " message");
System.Threading.Thread.Sleep(500);
i++;
}
/*StreamReader sr = new StreamReader(@"C:\cases\117111317142938\request.json");
* string json = sr.ReadToEnd();
* EventData data = new EventData(Encoding.UTF8.GetBytes(json));
* client.Send(data);*/
}
static async Task SendEventsAsync()
{
// Create EventHubClient
EventHubClient client = EventHubClient.Create(eventHubName);
while (true)
{
try
{
// Send messages to Event Hub
Console.WriteLine("Sending messages to Event Hub {0}", client.Path);
string messageBody = Guid.NewGuid().ToString();
// Create the device/temperature metric
EventData data = new EventData(Encoding.UTF8.GetBytes(messageBody));
// Send the metric to Event Hub
await client.SendAsync(data);
Console.WriteLine("Sent message {0} ", messageBody);
}
catch (Exception exp)
{
Console.WriteLine("Error on send: " + exp.Message);
}
Thread.Sleep(TimeSpan.FromSeconds(1));
}
}
public async void SendVehicleAlerts()
{
var client = EventHubClient.Create(this.eventHubName);
try
{
while (true)
{
var alert = new SpeedCameraAlert()
{
DeviceID = this.deviceID,
CameraID = this.cameraName,
Time = DateTime.UtcNow,
SpeedLimit = this.speedLimitForLocation,
VehicleRegistration = getRegistration(),
Speed = getSpeed()
};
var serializedAlert = JsonConvert.SerializeObject(alert);
var data = new EventData(Encoding.UTF8.GetBytes(serializedAlert));
data.Properties.Add("Type", $"Telemetry_{DateTime.Now.ToLongTimeString()}");
Trace.TraceInformation($"Sending: {alert.ToString()}");
await client.SendAsync(data);
await Task.Delay(rnd.Next(10) * 500);
}
}
catch (Exception e)
{
Trace.TraceError($"Error sending message: {e.Message}");
}
client.CloseAsync().Wait();
}
public IEventHubClient Create(string connectionString, TimeSpan receiveTimeout)
{
EventHubsConnectionStringBuilder csb = new EventHubsConnectionStringBuilder(connectionString);
csb.OperationTimeout = receiveTimeout;
return(new EventHubClientWrapper(EventHubClient.Create(csb)));
}
static void Main(string[] args)
{
if (args.Length < 3)
{
Usage();
}
eventHubName = ConfigurationManager.AppSettings["EventHubName"];
client = EventHubClient.Create(eventHubName);
var engine = new TelcoGenerationEngine(client);
// Show Usage information
if (args.Length < 3)
{
Usage();
}
string connectionString = engine.GetServiceBusConnectionString();
NamespaceManager namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
partitionCurrent = 0;
// Assumes you already have the Event Hub created.
// Generate the data
engine.GenerateData(args);
Console.ReadKey();
}
public async void SendStockAlerts()
{
var client = EventHubClient.Create(this.eventHubName);
try
{
while (true)
{
var alert = new StockPriceChangeEvent()
{
Ticker = this.ticker,
Price = getPrice(),
QuoteTime = getQuoteTime()
};
var serializedAlert = JsonConvert.SerializeObject(alert);
var data = new EventData(Encoding.UTF8.GetBytes(serializedAlert));
data.Properties.Add("Type", $"Telemetry_{DateTime.Now.ToLongTimeString()}");
Trace.TraceInformation($"Sending: {alert.ToString()}");
await client.SendAsync(data);
await Task.Delay(rnd.Next(10) * 500);
}
}
catch (Exception e)
{
Trace.TraceError($"Error sending message: {e.Message}");
}
client.CloseAsync().Wait();
}
static void Main(string[] args)
{
// Show Usage information
if (args.Length < 3)
{
Usage();
}
// Init
_init();
// Setup service bus
string connectionString = GetServiceBusConnectionString();
NamespaceManager namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
eventHubName = ConfigurationManager.AppSettings["EventHubName"];
partitionCurrent = 0;
// Assumes you already have the Event Hub created.
client = EventHubClient.Create(eventHubName);
// Generate the data
GenerateData(args);
Console.ReadKey();
}
private static EventHubSender CreatePartitionedSender()
{
// EventHubClient model (uses implicit factory instance, so all links on same connection)
EventHubClient eventHubClient = EventHubClient.Create("contoso-trucks");
// return sender for partition '1'
return(eventHubClient.CreatePartitionedSender("1"));
}
static void ClientCredentialsScenario()
{
ClientCredential clientCredential = new ClientCredential(ClientId, ConfigurationManager.AppSettings["clientSecret"]);
TokenProvider tp = TokenProvider.CreateAadTokenProvider(new AuthenticationContext($"https://login.windows.net/{TenantId}"), clientCredential);
var ehClient = EventHubClient.Create(new Uri($"sb://{EventHubNamespace}/"), EventHubName, tp);
SendReceiveAsync(ehClient).Wait();
}
static void ClientAssertionCertScenario()
{
X509Certificate2 certificate = GetCertificate();
ClientAssertionCertificate clientAssertionCertificate = new ClientAssertionCertificate(ClientId, certificate);
TokenProvider tp = TokenProvider.CreateAadTokenProvider(new AuthenticationContext($"https://login.windows.net/{TenantId}"), clientAssertionCertificate);
var ehClient = EventHubClient.Create(new Uri($"sb://{EventHubNamespace}/"), EventHubName, tp);
SendReceiveAsync(ehClient).Wait();
}
static void UserInteractiveLoginScenario()
{
TokenProvider tp = TokenProvider.CreateAadTokenProvider(
new AuthenticationContext($"https://login.windows.net/{TenantId}"),
ClientId,
new Uri("http://eventhubs.microsoft.com"),
new PlatformParameters(PromptBehavior.Auto),
UserIdentifier.AnyUser
);
var ehClient = EventHubClient.Create(new Uri($"sb://{EventHubNamespace}/"), EventHubName, tp);
SendReceiveAsync(ehClient).Wait();
}
public ServiceBus()
{
ServiceBusEnvironment.SystemConnectivity.Mode = Microsoft.ServiceBus.ConnectivityMode.Http;
// Setup service bus
string connectionString = GetServiceBusConnectionString();
NamespaceManager namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
eventHubName = ConfigurationManager.AppSettings["EventHubName"];
registryManager = RegistryManager.CreateFromConnectionString(connectionString);
client = EventHubClient.Create(eventHubName);
}
static void Main(string[] args)
{
GenConfig config = new GenConfig(args);
// Setup service bus
string connectionString = GetServiceBusConnectionString();
NamespaceManager namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
eventHubName = ConfigurationManager.AppSettings["EventHubName"];
client = EventHubClient.Create(eventHubName);
GenerateData(config);
Console.ReadKey();
}
public AppModel()
{
Position = ObservableProperty.CreateSettable(new Point());
var client = EventHubClient.Create("sakapon-event-201508");
var index = 0;
Position
.Select(p => new { index = index++, position = p.ToString() })
.Select(o => JsonConvert.SerializeObject(o))
.Do(m => Debug.WriteLine("Sending message. {0}", new[] { m }))
.Select(m => new EventData(Encoding.UTF8.GetBytes(m)))
.Subscribe(d => client.SendAsync(d));
}
public async Task SendEventHubsMessage()
{
string hubNamespace = _settings.EventHubNamespace;
var endpoint = new Uri($"sb://{hubNamespace}.servicebus.windows.net/");
string hubName = _settings.EventHubName;
var client = EventHubClient.Create(
endpoint,
hubName,
new ManagedIdentityEventHubsTokenProvider(_settings.ManagedIdentityTenantId));
// You can also do this:
// var client = EventHubClient.CreateWithManagedServiceIdentity(endpoint, hubName);
byte[] bytes = Encoding.UTF8.GetBytes($"Test message {Guid.NewGuid()} ({DateTime.UtcNow:HH:mm:ss})");
await client.SendAsync(new EventData(bytes));
}
private static EventHubReceiver GetEventHubReceiver(SiteState state)
{
// Create the EventHubClient and retrieve the default consumer group
EventHubClient eventHubClient = EventHubClient.Create("contoso-trucks");
EventHubConsumerGroup defaultConsumberGroup = eventHubClient.GetDefaultConsumerGroup();
// if state ontains an offset, then use it; otherwise use the default (beginning of stream)
if (string.IsNullOrEmpty(state.Offset))
{
return(defaultConsumberGroup.CreateReceiver("1"));
}
else
{
return(defaultConsumberGroup.CreateReceiver("1", state.Offset));
}
}
internal EventHubClient CreateEventHubClient()
{
// Token provider already provided?
if (this.tokenProvider == null)
{
return(EventHubClient.CreateFromConnectionString(this.eventHubConnectionString));
}
else
{
return(EventHubClient.Create(
this.EndpointAddress,
this.EventHubPath,
this.tokenProvider,
this.OperationTimeout,
this.TransportType));
}
}
public bool SendEvents(string homeHubId, DateTime dt, string sensorName, string sensorRole, string sensorData)
{
// Create EventHubClient
EventHubClient client = EventHubClient.Create(this.eventHubName);
bool bEventSent = false;
try
{
List <Task> tasks = new List <Task>();
// Send messages to Event Hub
Console.WriteLine("Sending messages to Event Hub {0}", client.Path);
// Create the device/temperature metric
MetricEvent info = new MetricEvent()
{
HomeHubId = homeHubId, SensorName = sensorName, SensorData = sensorData, SensorRole = sensorRole,
EntryDateTime = dt
};
var serializedString = JsonConvert.SerializeObject(info);
EventData data = new EventData(Encoding.UTF8.GetBytes(serializedString))
{
PartitionKey = info.HomeHubId.ToString()
};
// Set user properties if needed
data.Properties.Add("Type", "Telemetry_" + DateTime.Now.ToLongTimeString());
OutputMessageInfo(DateTime.Now.ToString() + " SENDING: ", data, info);
// Send the metric to Event Hub
tasks.Add(client.SendAsync(data));
Task.WaitAll(tasks.ToArray());
bEventSent = true;
}
catch (Exception exp)
{
Console.WriteLine("Error on send: " + exp.Message);
}
client.CloseAsync().Wait();
return(bEventSent);
}
public void SendEvents()
{
// Create EventHubClient
EventHubClient client = EventHubClient.Create(this.eventHubName);
try
{
List <Task> tasks = new List <Task>();
// Send messages to Event Hub
Console.WriteLine("Sending messages to Event Hub {0}", client.Path);
Random random = new Random();
for (int i = 0; i < this.numberOfMessages; ++i)
{
// Create the device/temperature metric
MetricEvent info = new MetricEvent()
{
DeviceId = random.Next(numberOfDevices), Temperature = random.Next(100)
};
var serializedString = JsonConvert.SerializeObject(info);
EventData data = new EventData(Encoding.UTF8.GetBytes(serializedString))
{
PartitionKey = info.DeviceId.ToString()
};
// Set user properties if needed
data.Properties.Add("Type", "Telemetry_" + DateTime.Now.ToLongTimeString());
OutputMessageInfo("SENDING: ", data, info);
// Send the metric to Event Hub
tasks.Add(client.SendAsync(data));
}
;
Task.WaitAll(tasks.ToArray());
}
catch (Exception exp)
{
Console.WriteLine("Error on send: " + exp.Message);
}
client.CloseAsync().Wait();
}
static void Main(string[] args)
{
// Show Usage information
if (args.Length < 3)
{
Usage();
}
// Setup service bus
string connectionString = GetServiceBusConnectionString();
NamespaceManager namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
eventHubName = ConfigurationManager.AppSettings["EventHubName"];
client = EventHubClient.Create(eventHubName);
GenerateData(args);
Console.ReadKey();
}
public async Task UseITokenProviderWithSas()
{
// Generate SAS token provider.
var csb = new EventHubsConnectionStringBuilder(TestUtility.EventHubsConnectionString);
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(csb.SasKeyName, csb.SasKey);
// Create new client with updated connection string.
var ehClient = EventHubClient.Create(csb.Endpoint, csb.EntityPath, tokenProvider);
// Send one event
TestUtility.Log($"Sending one message.");
var ehSender = ehClient.CreatePartitionSender("0");
var eventData = new EventData(Encoding.UTF8.GetBytes("Hello EventHub!"));
await ehSender.SendAsync(eventData);
// Receive event.
PartitionReceiver ehReceiver = null;
try
{
TestUtility.Log($"Receiving one message.");
ehReceiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, "0", EventPosition.FromStart());
var msg = await ehReceiver.ReceiveAsync(1);
Assert.True(msg != null, "Failed to receive message.");
}
finally
{
await ehReceiver?.CloseAsync();
}
// Get EH runtime information.
TestUtility.Log($"Getting Event Hub runtime information.");
var ehInfo = await ehClient.GetRuntimeInformationAsync();
Assert.True(ehInfo != null, "Failed to get runtime information.");
// Get EH partition runtime information.
TestUtility.Log($"Getting Event Hub partition '0' runtime information.");
var partitionInfo = await ehClient.GetPartitionRuntimeInformationAsync("0");
Assert.True(ehInfo != null, "Failed to get runtime partition information.");
}
public async Task UseITokenProviderWithAad()
{
var tenantId = "";
var aadAppId = "";
var aadAppSecret = "";
if (string.IsNullOrEmpty(tenantId))
{
TestUtility.Log($"Skipping test during scheduled runs.");
return;
}
var authContext = new AuthenticationContext($"https://login.windows.net/{tenantId}");
var cc = new ClientCredential(aadAppId, aadAppSecret);
var tokenProvider = TokenProvider.CreateAadTokenProvider(authContext, cc);
// Create new client with updated connection string.
var csb = new EventHubsConnectionStringBuilder(TestUtility.EventHubsConnectionString);
var ehClient = EventHubClient.Create(csb.Endpoint, csb.EntityPath, tokenProvider);
// Send one event
TestUtility.Log($"Sending one message.");
var ehSender = ehClient.CreatePartitionSender("0");
var eventData = new EventData(Encoding.UTF8.GetBytes("Hello EventHub!"));
await ehSender.SendAsync(eventData);
// Receive event.
PartitionReceiver ehReceiver = null;
try
{
TestUtility.Log($"Receiving one message.");
ehReceiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, "0", EventPosition.FromStart());
var msg = await ehReceiver.ReceiveAsync(1);
Assert.True(msg != null, "Failed to receive message.");
}
finally
{
await ehReceiver?.CloseAsync();
}
}
static async Task Main(string[] args)
{
Console.WriteLine("Start receiver...");
_listenerThread = new Thread(Receiver);
_listenerThread.Start();
Console.WriteLine("Start forwarder...");
var ehConnection = new EventHubsConnectionStringBuilder(_forwarder.EventHub.ConnectionString)
{
EntityPath = _forwarder.EventHub.EventHubName
};
var ehClient = EventHubClient.Create(ehConnection);
var events = new List <EventData>(2048);
while (true)
{
while (!_waitHandles.IsEmpty)
{
if (ehClient.IsClosed)
{
ehClient = EventHubClient.Create(ehConnection);
}
Console.WriteLine($"Preparing forwarding batch...");
events.Clear();
while (_waitHandles.TryDequeue(out var eventData))
{
events.Add(eventData);
}
if (events.Any())
{
Console.WriteLine($"Forward {events.Count} event(s)...");
await ehClient.SendAsync(events);
}
}
await Task.Delay(_forwarder.IterationInterval);
}
}
static void Produce(CancellationToken cancellationToken)
{
var hub = EventHubClient.Create("unaigab2016");
while (true)
{
if (cancellationToken.IsCancellationRequested)
{
return;
}
var sensor = new Sensor()
{
Value = _next.NextDouble(),
Name = ((DateTime.UtcNow.Second & 1) == 1) ? "Sensor-A" : "Sensor-B"
};
hub.SendAsync(new EventData(
UTF8Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(sensor)))).Wait();
}
}
private bool InitializeHubClient(string eventHubname)
{
if (_isInitialized)
{
return(true);
}
string hubname = (string.IsNullOrEmpty(eventHubname)) ? ConfigurationManager.AppSettings["Microsoft.Eventhub.Name"] : eventHubname;
if (!string.IsNullOrEmpty(hubname))
{
// Creates a new instance of the EventHubClient instance, using a connection string from the application configuration settings
if ((_hubClient = EventHubClient.Create(hubname)) != null)
{
return(_isInitialized = true);
}
}
// Failed condition
return(false);
}
/// <summary>
/// Instantiate publishing on this bus by
/// calling <see cref="CheckPrivateHubExists"/> and <see cref="CheckPublicHubExists"/>
/// then calling <see cref="AzureBus{TAuthenticationToken}.StartSettingsChecking"/>
/// </summary>
protected override void InstantiatePublishing()
{
#if NET452
Manager manager = Manager.CreateFromConnectionString(ConnectionString);
#endif
#if NETSTANDARD2_0
var manager = new Manager(ConnectionString);
#endif
CheckPrivateHubExists(manager);
CheckPublicHubExists(manager);
#if NET452
EventHubPublisher = EventHubClient.CreateFromConnectionString(ConnectionString, PublicEventHubName);
#endif
#if NETSTANDARD2_0
var connectionStringBuilder = new EventHubsConnectionStringBuilder(ConnectionString)
{
EntityPath = PublicEventHubName
};
EventHubPublisher = EventHubClient.Create(connectionStringBuilder);
#endif
StartSettingsChecking();
}
static void Main(string[] args)
{
//Create the event hub
var manager = Microsoft.ServiceBus.NamespaceManager.CreateFromConnectionString(ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"]);
var tweethub = manager.CreateEventHubIfNotExists("TweetHubSimple");
tweetHubClient = EventHubClient.Create(tweethub.Path);
var oauth = CredentialsCreator_CreateFromRedirectedCallbackURL_SingleStep(ConfigurationManager.AppSettings["twitterkey"], ConfigurationManager.AppSettings["twittersecret"]);
// Setup your credentials
TwitterCredentials.SetCredentials(oauth.AccessToken, oauth.AccessTokenSecret, oauth.ConsumerKey, oauth.ConsumerSecret);
// Access the filtered stream
var filteredStream = Tweetinvi.Stream.CreateFilteredStream();
filteredStream.AddTrack("globalazurebootcamp");
filteredStream.AddTrack("azure");
filteredStream.AddTrack("microsoft");
filteredStream.MatchingTweetReceived += (sender, a) => {
Console.WriteLine(a.Tweet.Text);
var str = JsonConvert.SerializeObject(new
{
Tweet = a.Tweet.Text,
Lang = a.Tweet.Language,
Created_At = a.Tweet.CreatedAt
});
tweetHubClient.Send(new EventData(System.Text.Encoding.UTF8.GetBytes(str)));
};
//filteredStream.JsonObjectReceived += (sender, json) =>
//{
// ProcessTweet(json.Json);
//};
filteredStream.StartStreamMatchingAllConditions();
}
public EventHubReceiver(EventHubsConnectionStringBuilder connectionString)
{
_connectionString = connectionString;
_eventHubClient = EventHubClient.Create(connectionString);
}
public EventHubSender(EventHubsConnectionStringBuilder connectionString)
{
_eventHubClient = EventHubClient.Create(connectionString);
}
