/// <summary> /// Adds a row to current Log file. /// </summary> /// <param name="columns">Columns to write on row.</param> /// <param name="separator">Column separator.</param> public void AddRow(string[] columns, string separator = " ") { var row = new StringBuilder(); row.Append(DateTime.UtcNow); foreach (string column in columns) { row.Append(separator); row.Append(column); } if (Async) { ActiveQueue.Enqueue(row.ToString()); if (!Writing) { StartTask(); } } else { CheckIfNewFileNeeded(); TryWrite(CurrentLogFile, row.ToString()); } }
public async override Task <ResourceResponse[]> SendActivities(ITurnContext context, Activity[] activities) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (activities == null) { throw new ArgumentNullException(nameof(activities)); } if (activities.Length == 0) { throw new ArgumentException("Expecting one or more activities, but the array was empty.", nameof(activities)); } var responses = new ResourceResponse[activities.Length]; // NOTE: we're using for here (vs. foreach) because we want to simultaneously index into the // activities array to get the activity to process as well as use that index to assign // the response to the responses array and this is the most cost effective way to do that. for (var index = 0; index < activities.Length; index++) { var activity = activities[index]; if (String.IsNullOrEmpty(activity.Id)) { activity.Id = Guid.NewGuid().ToString("n"); } if (activity.Timestamp == null) { activity.Timestamp = DateTime.UtcNow; } if (activity.Type == ActivityTypesEx.Delay) { // The BotFrameworkAdapter and Console adapter implement this // hack directly in the POST method. Replicating that here // to keep the behavior as close as possible to facillitate // more realistic tests. int delayMs = (int)activity.Value; await Task.Delay(delayMs); } else { lock (_activeQueueLock) { ActiveQueue.Enqueue(activity); } } responses[index] = new ResourceResponse(activity.Id); } return(responses); }
/// <summary> /// Called by TestFlow to check next reply /// </summary> /// <returns></returns> public IActivity GetNextReply() { lock (_activeQueueLock) { if (ActiveQueue.Count > 0) { return(ActiveQueue.Dequeue()); } } return(null); }
/// <summary> /// Creates a new conversation on the specified channel. /// </summary> /// <param name="channelId">The ID of the channel.</param> /// <param name="callback">The bot logic to call when the conversation is created.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects /// or threads to receive notice of cancellation.</param> /// <returns>A task that represents the work queued to execute.</returns> /// <remarks>This resets the <see cref="ActiveQueue"/>, and does not maintain multiple converstion queues.</remarks> public Task CreateConversationAsync(string channelId, BotCallbackHandler callback, CancellationToken cancellationToken) { ActiveQueue.Clear(); var update = Activity.CreateConversationUpdateActivity(); update.Conversation = new ConversationAccount() { Id = Guid.NewGuid().ToString("n") }; var context = new TurnContext(this, (Activity)update); return(callback(context, cancellationToken)); }
/// <summary> /// NOTE: this resets the queue, it doesn't actually maintain multiple converstion queues /// </summary> /// <param name="channelId"></param> /// <param name="callback"></param> /// <returns></returns> //public override Task CreateConversation(string channelId, Func<ITurnContext, Task> callback) public Task CreateConversation(string channelId, Func <ITurnContext, Task> callback) { ActiveQueue.Clear(); var update = Activity.CreateConversationUpdateActivity(); update.Conversation = new ConversationAccount() { Id = Guid.NewGuid().ToString("n") }; var context = new TurnContext(this, (Activity)update); return(callback(context)); }
private void Enqueue(Activity activity) { lock (_activeQueueLock) { // if there are pending requests, fulfill them with the activity. while (_queuedRequests.Any()) { var tcs = _queuedRequests.Dequeue(); if (tcs.Task.IsCanceled == false) { tcs.SetResult(activity); return; } } // else we enqueue for next requester ActiveQueue.Enqueue(activity); } }
public override Task DeleteActivity(ITurnContext context, ConversationReference reference) { lock (_activeQueueLock) { var replies = ActiveQueue.ToList(); for (int i = 0; i < ActiveQueue.Count; i++) { if (replies[i].Id == reference.ActivityId) { replies.RemoveAt(i); ActiveQueue.Clear(); foreach (var item in replies) { ActiveQueue.Enqueue(item); } break; } } } return(Task.CompletedTask); }
public override Task <ResourceResponse> UpdateActivity(ITurnContext context, Activity activity) { lock (_activeQueueLock) { var replies = ActiveQueue.ToList(); for (int i = 0; i < ActiveQueue.Count; i++) { if (replies[i].Id == activity.Id) { replies[i] = activity; ActiveQueue.Clear(); foreach (var item in replies) { ActiveQueue.Enqueue(item); } return(Task.FromResult(new ResourceResponse(activity.Id))); } } } return(Task.FromResult(new ResourceResponse())); }