public void TrackEvent(string str, string[] parameters, bool flush)
{
Dictionary <string, string> dr = new Dictionary <string, string>();
for (int index = 0; index < parameters.GetLength(0); index += 2)
{
if (string.IsNullOrEmpty(parameters[index + 1]))
{
continue;
}
dr.Add(parameters[index], parameters[index + 1]);
}
if (InnerClient == null)
{
return;
}
InnerClient.TrackEvent(str, dr);
if (flush)
{
if (Count > 10)
{
Task.Run(() => { InnerClient.Flush(); });
Count = 0;
}
else
{
Count++;
}
}
}
public void Flush()
{
if (InnerClient != null)
{
InnerClient.Flush();
}
}
public void UpdateCommands()
{
if (BroadcastId == null)
{
return;
}
Task t = InnerClient.GetUpdatesAsync(0, 2, 0, new Telegram.Bot.Types.Enums.UpdateType[] { Telegram.Bot.Types.Enums.UpdateType.All }).ContinueWith(task => {
foreach (Update upd in task.Result)
{
if (upd.Message.Date <= LastCommandTime)
{
continue;
}
LastCommandTime = upd.Message.Date;
if (upd.Message.Chat.Id == BroadcastId.Identifier)
{
if (upd.Message.Text == "/stopit!")
{
IsActive = false;
InnerClient.SendTextMessageAsync(BroadcastId, "I am stopped!");
}
if (upd.Message.Text == "/startit")
{
IsActive = true;
InnerClient.SendTextMessageAsync(BroadcastId, "I am started!");
}
break;
}
}
});
t.Wait(10000);
}
public void SendMessage(MessageBase msg)
{
var om = InnerClient.CreateMessage();
msg.Write(om);
SendMessage(om);
}
/// <summary>
/// Starts the partition pump. In case it's already running, nothing happens.
/// </summary>
///
/// <returns>A task to be resolved on when the operation has completed.</returns>
///
public async Task StartAsync()
{
if (RunningTask == null)
{
await RunningTaskSemaphore.WaitAsync().ConfigureAwait(false);
try
{
if (RunningTask == null)
{
RunningTaskTokenSource?.Cancel();
RunningTaskTokenSource = new CancellationTokenSource();
InnerConsumer = InnerClient.CreateConsumer(ConsumerGroup, PartitionId, Options.InitialEventPosition);
await PartitionProcessor.InitializeAsync().ConfigureAwait(false);
RunningTask = RunAsync(RunningTaskTokenSource.Token);
}
}
finally
{
RunningTaskSemaphore.Release();
}
}
}
/// <summary>
/// Starts the partition pump. In case it's already running, nothing happens.
/// </summary>
///
/// <returns>A task to be resolved on when the operation has completed.</returns>
///
public async Task StartAsync()
{
if (RunningTask == null)
{
await RunningTaskSemaphore.WaitAsync().ConfigureAwait(false);
try
{
if (RunningTask == null)
{
// We expect the token source to be null, but we are playing safe.
RunningTaskTokenSource?.Cancel();
RunningTaskTokenSource = new CancellationTokenSource();
InnerConsumer = InnerClient.CreateConsumer(ConsumerGroup, Context.PartitionId, Options.InitialEventPosition);
// In case an exception is encountered while partition processor is initializing, don't catch it
// and let the event processor handle it. The inner consumer hasn't connected to the service yet,
// so there's no need to close it.
await PartitionProcessor.InitializeAsync(Context).ConfigureAwait(false);
// Before closing, the running task will set the close reason in case of failure. When something
// unexpected happens and it's not set, the default value (Unknown) is kept.
RunningTask = RunAsync(RunningTaskTokenSource.Token);
}
}
finally
{
RunningTaskSemaphore.Release();
}
}
}
private void RecivePacket(object peer)
{
NetIncomingMessage msg;
while ((msg = InnerClient.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.VerboseDebugMessage:
break;
case NetIncomingMessageType.DiscoveryResponse:
InnerClient.Connect(msg.SenderEndPoint);
break;
case NetIncomingMessageType.StatusChanged:
OnStatusMessage(this, msg);
break;
case NetIncomingMessageType.Data:
OnDataMessage(this, msg);
break;
}
}
}
public void SendMessage(NetOutgoingMessage msg)
{
if (InnerClient.Status == NetPeerStatus.Running)
{
InnerClient.SendMessage(msg, NetDeliveryMethod.Unreliable);
}
}
public void DisConnect()
{
if (InnerClient.Status == NetPeerStatus.Running)
{
InnerClient.Disconnect("Disconnect");
InnerClient.Shutdown("Shutdown");
}
}
public void Connect(String ip, int port)
{
if (InnerClient.Status != NetPeerStatus.Running)
{
InnerClient.Start();
NetOutgoingMessage hail = InnerClient.CreateMessage("This is the hail message");
InnerClient.Connect(ip, port, hail);
}
}
/// <summary>
/// Creates an Event Hub producer responsible for publishing <see cref="EventData" /> to the
/// Event Hub, either as a single item or grouped together in batches. Depending on the
/// <paramref name="producerOptions"/> specified, the producer may be created to allow event
/// data to be automatically routed to an available partition or specific to a partition.
/// </summary>
///
/// <param name="producerOptions">The set of options to apply when creating the producer.</param>
///
/// <returns>An Event Hub producer configured in the requested manner.</returns>
///
/// <remarks>
/// Allowing automatic routing of partitions is recommended when:
/// <para>- The publishing of events needs to be highly available.</para>
/// <para>- The event data should be evenly distributed among all available partitions.</para>
///
/// If no partition is specified, the following rules are used for automatically selecting one:
/// <para>- Distribute the events equally amongst all available partitions using a round-robin approach.</para>
/// <para>- If a partition becomes unavailable, the Event Hubs service will automatically detect it and forward the message to another available partition.</para>
/// </remarks>
///
public virtual EventHubProducer CreateProducer(EventHubProducerOptions producerOptions = default)
{
var options = producerOptions?.Clone() ?? new EventHubProducerOptions {
Retry = null, Timeout = null
};
options.Retry = options.Retry ?? ClientOptions.Retry.Clone();
options.Timeout = options.TimeoutOrDefault ?? ClientOptions.DefaultTimeout;
return(InnerClient.CreateProducer(options));
}
public void AnnounceOfflineAsync(EndpointDiscoveryMetadata discoveryMetadata, object userState)
{
if (discoveryMetadata == null)
{
throw FxTrace.Exception.ArgumentNull("discoveryMetadata");
}
using (new AnnouncementOperationContextScope(InnerChannel))
{
InnerClient.ByeOperationAsync(discoveryMetadata, userState);
}
}
public IAsyncResult BeginAnnounceOffline(EndpointDiscoveryMetadata discoveryMetadata, AsyncCallback callback, object state)
{
if (discoveryMetadata == null)
{
throw FxTrace.Exception.ArgumentNull("discoveryMetadata");
}
using (new AnnouncementOperationContextScope(InnerChannel))
{
return(InnerClient.BeginByeOperation(discoveryMetadata, callback, state));
}
}
public void SendNotification(string text, long chatId)
{
TelegramClientInfo client = null;
Clients.TryGetValue(chatId, out client);
if (client == null || !client.Enabled)
{
return;
}
InnerClient.SendTextMessageAsync(client.ChatId, text, Telegram.Bot.Types.Enums.ParseMode.Html);
}
public override void Dispose()
{
if (!IsDisposed)
{
if (InnerClient != null)
{
InnerClient.Dispose();
InnerClient = null;
}
IsDisposed = true;
}
}
/// <summary>
/// Creates an event receiver responsible for reading <see cref="EventData" /> from a specific Event Hub partition,
/// and as a member of a specific consumer group.
///
/// A receiver may be exclusive, which asserts ownership over the partition for the consumer
/// group to ensure that only one receiver from that group is reading the from the partition.
/// These exclusive receivers are sometimes referred to as "Epoch Receivers."
///
/// A receiver may also be non-exclusive, allowing multiple receivers from the same consumer
/// group to be actively reading events from the partition. These non-exclusive receivers are
/// sometimes referred to as "Non-epoch Receivers."
///
/// Designating a receiver as exclusive may be specified in the <paramref name="receiverOptions" />.
/// By default, receivers are created as non-exclusive.
/// </summary>
///
/// <param name="partitionId">The identifier of the Event Hub partition from which events will be received.</param>
/// <param name="receiverOptions">The set of options to apply when creating the receiver.</param>
///
/// <returns>An event receiver configured in the requested manner.</returns>
///
/// <remarks>
/// If the starting event position is not specified in the <paramref name="receiverOptions"/>, the receiver will
/// default to ignoring events in the partition that were queued prior to the receiver being created and read only
/// events which appear after that point.
/// </remarks>
///
public virtual EventReceiver CreateReceiver(string partitionId,
EventReceiverOptions receiverOptions = default)
{
Guard.ArgumentNotNullOrEmpty(nameof(partitionId), partitionId);
var options = receiverOptions?.Clone() ?? new EventReceiverOptions {
Retry = null, DefaultMaximumReceiveWaitTime = null
};
options.Retry = options.Retry ?? ClientOptions.Retry.Clone();
options.DefaultMaximumReceiveWaitTime = options.MaximumReceiveWaitTimeOrDefault ?? ClientOptions.DefaultTimeout;
return(InnerClient.CreateReceiver(partitionId, options));
}
private async Task <HttpResponseMessage> SendRequest(string url, HttpMethod method, HttpContent data, bool login)
{
if (method == null)
{
method = HttpMethod.Get;
}
var request = new HttpRequestMessage(method, url);
if (data != null && method != HttpMethod.Get)
{
request.Content = data;
}
AddHeaders(request);
return(await InnerClient.SendAsync(request));
}
bool RegisterNewUsers(Update[] result)
{
foreach (Update upd in result)
{
if (upd.Message.Text.Trim() == "/regme " + RegistrationCode)
{
BroadcastId = upd.Message.Chat.Id;
XtraMessageBox.Show("Telegram bot successfully registered!");
InnerClient.SendTextMessageAsync(BroadcastId, "Hello my friend!");
SettingsStore.Default.TelegramBotBroadcastId = BroadcastId.Identifier;
IsActive = true;
return(true);
}
}
return(false);
}
/// <summary>
/// Creates an Event Hub consumer responsible for reading <see cref="EventData" /> from a specific Event Hub partition,
/// in the context of a specific consumer group.
///
/// A consumer may be exclusive, which asserts ownership over the partition for the consumer
/// group to ensure that only one consumer from that group is reading the from the partition.
/// These exclusive consumers are sometimes referred to as "Epoch Consumers."
///
/// A consumer may also be non-exclusive, allowing multiple consumers from the same consumer
/// group to be actively reading events from the partition. These non-exclusive consumers are
/// sometimes referred to as "Non-epoch Consumers."
///
/// Designating a consumer as exclusive may be specified in the <paramref name="consumerOptions" />.
/// By default, consumers are created as non-exclusive.
/// </summary>
///
/// <param name="consumerGroup">The name of the consumer group this consumer is associated with. Events are read in the context of this group.</param>
/// <param name="partitionId">The identifier of the Event Hub partition from which events will be received.</param>
/// <param name="eventPosition">The position within the partition where the consumer should begin reading events.</param>
/// <param name="consumerOptions">The set of options to apply when creating the consumer.</param>
///
/// <returns>An Event Hub consumer configured in the requested manner.</returns>
///
public virtual EventHubConsumer CreateConsumer(string consumerGroup,
string partitionId,
EventPosition eventPosition,
EventHubConsumerOptions consumerOptions = default)
{
Guard.ArgumentNotNullOrEmpty(nameof(partitionId), partitionId);
Guard.ArgumentNotNull(nameof(eventPosition), eventPosition);
var options = consumerOptions?.Clone() ?? new EventHubConsumerOptions {
Retry = null, DefaultMaximumReceiveWaitTime = null
};
options.Retry = options.Retry ?? ClientOptions.Retry.Clone();
options.DefaultMaximumReceiveWaitTime = options.MaximumReceiveWaitTimeOrDefault ?? ClientOptions.DefaultTimeout;
return(InnerClient.CreateConsumer(consumerGroup, partitionId, eventPosition, options));
}
private async Task <HttpResponseMessage> SendRequest(string url, CancellationToken token, HttpMethod method = null, HttpContent data = null, bool login = false)
{
if (method == null)
{
method = HttpMethod.Get;
}
var request = new HttpRequestMessage(method, url);
if (data != null && method != HttpMethod.Get)
{
request.Content = data;
}
AddHeaders(request);
if (!login)
{
AddAuth(request);
}
return(await InnerClient.SendAsync(request, token));
}
public void Update()
{
InnerClient.GetMeAsync().ContinueWith(u => {
Debug.Write(u.Result.Username);
});
InnerClient.GetUpdatesAsync().ContinueWith(task => {
if (!string.IsNullOrEmpty(RegistrationCode))
{
if (task.IsFaulted)
{
Telemetry.Default.TrackException(task.Exception);
}
else
{
RegisterNewUsers(task.Result);
}
}
RegistrationCode = string.Empty;
});
}
/// <summary>
/// Starts the event processor. In case it's already running, nothing happens.
/// </summary>
///
/// <returns>A task to be resolved on when the operation has completed.</returns>
///
public async Task StartAsync()
{
if (RunningTask == null)
{
await RunningTaskSemaphore.WaitAsync().ConfigureAwait(false);
try
{
if (RunningTask == null)
{
RunningTaskTokenSource?.Cancel();
RunningTaskTokenSource = new CancellationTokenSource();
PartitionPumps.Clear();
var partitionIds = await InnerClient.GetPartitionIdsAsync().ConfigureAwait(false);
await Task.WhenAll(partitionIds
.Select(partitionId =>
{
var partitionContext = new PartitionContext(InnerClient.EventHubName, ConsumerGroup, partitionId);
var checkpointManager = new CheckpointManager(partitionContext, Manager, Identifier);
var partitionProcessor = PartitionProcessorFactory(partitionContext, checkpointManager);
var partitionPump = new PartitionPump(InnerClient, ConsumerGroup, partitionId, partitionProcessor, Options);
PartitionPumps.TryAdd(partitionId, partitionPump);
return(partitionPump.StartAsync());
})).ConfigureAwait(false);
RunningTask = RunAsync(RunningTaskTokenSource.Token);
}
}
finally
{
RunningTaskSemaphore.Release();
}
}
}
/// <summary>
/// Finds and tries to claim an ownership if this <see cref="EventProcessor{T}" /> instance is eligible to increase its ownership
/// list.
/// </summary>
///
/// <param name="completeOwnershipEnumerable">A complete enumerable of ownership obtained from the stored service provided by the user.</param>
/// <param name="activeOwnership">The set of ownership that are still active.</param>
///
/// <returns>The claimed ownership. <c>null</c> if this instance is not eligible, if no claimable ownership was found or if the claim attempt failed.</returns>
///
private async Task <PartitionOwnership> FindAndClaimOwnershipAsync(IEnumerable <PartitionOwnership> completeOwnershipEnumerable,
IEnumerable <PartitionOwnership> activeOwnership)
{
// Get a complete list of the partition ids present in the Event Hub. This should be immutable for the time being, but
// it may change in the future.
var partitionIds = await InnerClient.GetPartitionIdsAsync().ConfigureAwait(false);
// Create a partition distribution dictionary from the active ownership list we have, mapping an owner's identifier to the amount of
// partitions it owns. When an event processor goes down and it has only expired ownership, it will not be taken into consideration
// by others.
var partitionDistribution = new Dictionary <string, int>
{
{ Identifier, 0 }
};
foreach (var ownership in activeOwnership)
{
if (partitionDistribution.TryGetValue(ownership.OwnerIdentifier, out var value))
{
partitionDistribution[ownership.OwnerIdentifier] = value + 1;
}
else
{
partitionDistribution[ownership.OwnerIdentifier] = 1;
}
}
// The minimum owned partitions count is the minimum amount of partitions every event processor needs to own when the distribution
// is balanced. If n = minimumOwnedPartitionsCount, a balanced distribution will only have processors that own n or n + 1 partitions
// each. We can guarantee the partition distribution has at least one key, which corresponds to this event processor instance, even
// if it owns no partitions.
var minimumOwnedPartitionsCount = partitionIds.Length / partitionDistribution.Keys.Count;
var ownedPartitionsCount = partitionDistribution[Identifier];
// There are two possible situations in which we may need to claim a partition ownership.
//
// The first one is when we are below the minimum amount of owned partitions. There's nothing more to check, as we need to claim more
// partitions to enforce balancing.
//
// The second case is a bit tricky. Sometimes the claim must be performed by an event processor that already has reached the minimum
// amount of ownership. This may happen, for instance, when we have 13 partitions and 3 processors, each of them owning 4 partitions.
// The minimum amount of partitions per processor is, in fact, 4, but in this example we still have 1 orphan partition to claim. To
// avoid overlooking this kind of situation, we may want to claim an ownership when we have exactly the minimum amount of ownership,
// but we are making sure there are no better candidates among the other event processors.
if (ownedPartitionsCount < minimumOwnedPartitionsCount ||
ownedPartitionsCount == minimumOwnedPartitionsCount && !partitionDistribution.Values.Any(partitions => partitions < minimumOwnedPartitionsCount))
{
// Look for unclaimed partitions. If any, randomly pick one of them to claim.
var unclaimedPartitions = partitionIds
.Except(activeOwnership.Select(ownership => ownership.PartitionId));
if (unclaimedPartitions.Any())
{
var index = RandomNumberGenerator.Value.Next(unclaimedPartitions.Count());
return(await ClaimOwnershipAsync(unclaimedPartitions.ElementAt(index), completeOwnershipEnumerable).ConfigureAwait(false));
}
// Only try to steal partitions if there are no unclaimed partitions left. At first, only processors that have exceeded the
// maximum owned partition count should be targeted.
var maximumOwnedPartitionsCount = minimumOwnedPartitionsCount + 1;
var stealablePartitions = activeOwnership
.Where(ownership => partitionDistribution[ownership.OwnerIdentifier] > maximumOwnedPartitionsCount)
.Select(ownership => ownership.PartitionId);
// Here's the important part. If there are no processors that have exceeded the maximum owned partition count allowed, we may
// need to steal from the processors that have exactly the maximum amount. If this instance is below the minimum count, then
// we have no choice as we need to enforce balancing. Otherwise, leave it as it is because the distribution wouldn't change.
if (!stealablePartitions.Any() && ownedPartitionsCount < minimumOwnedPartitionsCount)
{
stealablePartitions = activeOwnership
.Where(ownership => partitionDistribution[ownership.OwnerIdentifier] == maximumOwnedPartitionsCount)
.Select(ownership => ownership.PartitionId);
}
// If any stealable partitions were found, randomly pick one of them to claim.
if (stealablePartitions.Any())
{
var index = RandomNumberGenerator.Value.Next(stealablePartitions.Count());
return(await ClaimOwnershipAsync(stealablePartitions.ElementAt(index), completeOwnershipEnumerable).ConfigureAwait(false));
}
}
// No ownership was claimed.
return(null);
}
public void EndAnnounceOnline(IAsyncResult result)
{
InnerClient.EndHelloOperation(result);
}
public override void RefreshPool()
{
ThrowIfDisposed();
InnerClient.RefreshPool();
}
public void EndAnnounceOffline(IAsyncResult result)
{
InnerClient.EndByeOperation(result);
}
public void Flush()
{
InnerClient.Flush();
}
/// <summary> /// Retrieves information about an Event Hub, including the number of partitions present /// and their identifiers. /// </summary> /// /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> instance to signal the request to cancel the operation.</param> /// /// <returns>The set of information for the Event Hub that this client is associated with.</returns> /// public virtual Task <EventHubProperties> GetPropertiesAsync(CancellationToken cancellationToken = default) => InnerClient.GetPropertiesAsync(cancellationToken);
/// <summary> /// Closes the connection to the Event Hub instance. /// </summary> /// /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> instance to signal the request to cancel the operation.</param> /// /// <returns>A task to be resolved on when the operation has completed.</returns> /// public virtual Task CloseAsync(CancellationToken cancellationToken = default) => InnerClient.CloseAsync(cancellationToken);
/// <summary>
/// Retrieves information about a specific partiton for an Event Hub, including elements that describe the available
/// events in the partition event stream.
/// </summary>
///
/// <param name="partitionId">The unique identifier of a partition associated with the Event Hub.</param>
/// <param name="cancellationToken">An optional <see cref="CancellationToken"/> instance to signal the request to cancel the operation.</param>
///
/// <returns>The set of information for the requested partition under the Event Hub this client is associated with.</returns>
///
public virtual Task <PartitionProperties> GetPartitionPropertiesAsync(string partitionId,
CancellationToken cancellationToken = default) => InnerClient.GetPartitionPropertiesAsync(partitionId, cancellationToken);