public Task HashFile(LocalFile file)
{
if (file.LocalPath == null)
{
throw new ArgumentNullException(nameof(file));
}
if (!System.IO.File.Exists(file.LocalPath))
{
throw new ArgumentException("File does not exist");
}
if (this.queue.Any(t => ((LocalFile)t.Task.AsyncState).LocalPath == file.LocalPath))
{
throw new InvalidOperationException("File is already in queue");
}
var tcs = new TaskCompletionSource <bool>(state: file);
if (this.queue.TryAdd(tcs, 1000, this.cancellation.Token))
{
QueueChanged?.Invoke(this, EventArgs.Empty);
}
Start();
return(tcs.Task);
}
public void Like(string id, User user)
{
var index = Queue.FindIndex(x => x.SongId == id);
if (Queue[index].LikedBy.Contains(user))
{
UnlikeIndexed(index, user);
return;
}
Queue[index].LikeCount++;
Queue[index].LikedBy.Add(user);
if (index == 0)
{
QueueChanged?.Invoke(this, new QueueChangedEventArgs(QueueChangedEventArgs.EventTypes.SongLiked));
return;
}
var item = Queue[index];
while (index != 0 && item.LikeCount > Queue[index - 1].LikeCount)
{
index--;
}
Queue.Remove(item);
Queue.Insert(index, item);
QueueChanged?.Invoke(this, new QueueChangedEventArgs(QueueChangedEventArgs.EventTypes.SongLiked));
}
private async Task ProcessQueue()
{
Log.Info("Begin Queue processing");
QueueItem item;
while (Queue.TryTake(out item, Timeout.Infinite /*, cts.Token*/))
{
QueueChanged?.Invoke(this, new TransformQueueEventArgs(Queue.Count));
Log.Info($"Process item: {item.Key} ... (count: {Queue.Count})");
var tcs = item.TaskCompletionSource;
if (tcs.Task.IsCanceled || tcs.Task.IsCompleted || tcs.Task.IsFaulted)
{
Log.Info($" canceled: {item.Key}");
continue;
}
try
{
var result = await item.QueueTransformAsync(item.Key, item.Input);
tcs.SetResult(result);
}
catch (Exception ex)
{
tcs.TrySetException(ex);
}
}
Log.Info("End Queue processing");
}
public void Enqueue(QueueItem item)
{
QueueItem queueItem = GetOrAdd(item);
_queue.Enqueue(queueItem.TweetId);
QueueChanged?.Invoke(this, new ItemsChangedEventArgs(queueItem, null));
}
public async Task Add(string id, User user)
{
if (Contains(id))
{
Like(id, user);
return;
}
var track = await _service.Client.Tracks.Get(id);
var item = new QueueItem {
Track = track, AddedBy = user, SongId = track.Id
};
item.LikedBy.Add(user);
if (Queue.Count == 0 && CurrentlyPlaying == null)
{
CurrentlyPlaying = item;
QueueChanged?.Invoke(this, new QueueChangedEventArgs(QueueChangedEventArgs.EventTypes.PlayingSongChanged));
}
else
{
Queue.Add(item);
QueueChanged?.Invoke(this, new QueueChangedEventArgs(QueueChangedEventArgs.EventTypes.SongAdded));
}
}
public bool Dequeue(out QueueItem item)
{
if (_queue.TryDequeue(out long id))
{
item = _items[id];
QueueChanged?.Invoke(this, new ItemsChangedEventArgs(null, item));
return(true);
}
item = null;
return(false);
}
private void UnlikeIndexed(int index, User user)
{
if (Queue[index].LikeCount <= 1)
{
Queue.RemoveAt(index);
QueueChanged?.Invoke(this, new QueueChangedEventArgs(QueueChangedEventArgs.EventTypes.SongRemoved));
return;
}
Queue[index].LikeCount--;
Queue[index].LikedBy.Remove(user);
QueueChanged?.Invoke(this, new QueueChangedEventArgs(QueueChangedEventArgs.EventTypes.SongLiked));
}
public void Next()
{
if (Queue.Count == 0)
{
CurrentlyPlaying = null;
}
else
{
CurrentlyPlaying = Queue[0];
Queue.RemoveAt(0);
}
QueueChanged?.Invoke(this, new QueueChangedEventArgs(QueueChangedEventArgs.EventTypes.PlayingSongChanged));
}
public Task <TOutput> EnqueueTransform(TKey key, TInput input, QueueTransformAsync transformAsync)
{
foreach (var anItem in Queue)
{
if (anItem.Key.Equals(key))
{
Log.Info($"Task with key {key} already present");
return(anItem.TaskCompletionSource.Task);
}
}
var item = new QueueItem(key, input, transformAsync);
Queue.Add(item);
QueueChanged?.Invoke(this, new TransformQueueEventArgs(Queue.Count));
return(item.TaskCompletionSource.Task);
}
private void DoHashing()
{
try
{
TaskCompletionSource <bool> task;
while (!this.cancellation.IsCancellationRequested && this.queue.TryTake(out task, -1, this.cancellation.Token))
{
threads[Thread.CurrentThread] = task;
QueueChanged?.Invoke(this, EventArgs.Empty);
if (!task.Task.IsCanceled && !task.Task.IsCompleted)
{
try
{
Hash(task);
}
catch (ThreadAbortException)
{
this.loggingService.LogInfo("Aborting hashing of file.");
}
catch (Exception ex)
{
// XXX: Do something here!
this.loggingService.LogError("Problem while hashing file.", ex);
}
}
threads[Thread.CurrentThread] = null;
}
}
catch (ThreadAbortException)
{
// Someone called Stop(), that's OK.
}
catch (Exception ex)
{
// XXX: Do something here, we've aborted
// everything!
this.loggingService.LogError("AAHHHH!!!", ex);
Stop();
}
}
/// <summary>Генерация события, уведомляющего об изменении очереди</summary>
internal static void OnQueueChanged(QueueChangedEventArgs eventArgs)
{
QueueChanged?.Invoke(null, eventArgs);
}
public async Task RunAsync(CancellationToken stoppingToken)
{
var buffer = new ArraySegment <byte>(new byte[2048]);
await _webSocket.ConnectAsync(new Uri("ws://localhost:50080/connect"), CancellationToken.None);
while (!stoppingToken.IsCancellationRequested)
{
WebSocketReceiveResult received;
using MemoryStream data = new MemoryStream();
do
{
received = await _webSocket.ReceiveAsync(buffer, stoppingToken);
Console.WriteLine("Received {0} b ({1})", received.Count, received.EndOfMessage);
await data.WriteAsync(buffer.Slice(0, received.Count));
} while (!received.EndOfMessage);
var type = GetType(data);
switch (type)
{
case NotificationType.UserChanged:
{
var userNotification = UserChangedNotification.Parser.ParseFrom(data);
UsersChanged?.Invoke(this, new UserChangedEventArgs(userNotification));
break;
}
case NotificationType.QueueChanged:
{
var notification = QueueChangedNotification.Parser.ParseFrom(data);
QueueChanged?.Invoke(this, new ItemsChangedEventArgs(notification));
break;
}
case NotificationType.ItemsChanged:
{
var notification = QueueChangedNotification.Parser.ParseFrom(data);
ItemsChanged?.Invoke(this, new ItemsChangedEventArgs(notification));
break;
}
case NotificationType.ItemPlayed:
{
var notification = ItemPlayedNotification.Parser.ParseFrom(data);
ItemPlayed?.Invoke(this, new ItemPlayedEventArgs(notification));
break;
}
default:
Console.WriteLine("Unknown Type \"{0}\"", type);
break;
}
}
await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Bye", CancellationToken.None);
NotificationType GetType(MemoryStream data)
{
try
{
data.Seek(0, SeekOrigin.Begin);
var item = NotificationItem.Parser.ParseFrom(data);
Console.WriteLine("Parsed `NotificationItem`: {0}", item != null);
data.Seek(0, SeekOrigin.Begin);
return(item.Type);
}
catch (Exception e)
{
return(NotificationType.None);
}
}
}
private void OnQueueChanged()
{
QueueChanged?.Invoke(this, QueueCount);
}
private void FireQueueChangedEvent()
{
QueueChanged?.Invoke(this);
}
private void Synthesizer_QueueChanged(object sender, int e)
{
QueueChanged?.Invoke(sender, e);
}
protected virtual void OnQueueChanged(object source)
{
QueueChanged?.Invoke(source);
}
protected void FireQueueChanged()
{
QueueChanged?.Invoke(this);
}
