Skip to content

Usenet streaming with a WebDAV server and a SABnzbd-compatible API

C#

Fix logging of cancelled queue items.

nzbdav-dev186aa055a6cc
diff --git a/backend/Queue/FileProcessors/RarProcessor.cs b/backend/Queue/FileProcessors/RarProcessor.cs
index a2da65fa..2d0b15d6 100644
--- a/backend/Queue/FileProcessors/RarProcessor.cs
+++ b/backend/Queue/FileProcessors/RarProcessor.cs
@@ -30,13 +30,14 @@ public class RarProcessor(
try
{
await using var stream = await GetNzbFileStream();
+ await using var cancellableStream = new CancellableStream(stream, ct);
return new Result()
{
NzbFile = nzbFile,
- PartSize = stream.Length,
+ PartSize = cancellableStream.Length,
ArchiveName = GetArchiveName(),
PartNumber = GetPartNumber(),
- StoredFileSegments = GetRarHeaders(stream)
+ StoredFileSegments = (await Task.Run(() => GetRarHeaders(cancellableStream)))
.Select(x => new StoredFileSegment()
{
PathWithinArchive = x.GetFileName(),
@@ -75,10 +76,13 @@ public class RarProcessor(
private List<IRarHeader> GetRarHeaders(Stream stream)
{
+ ct.ThrowIfCancellationRequested();
var headerFactory = new RarHeaderFactory(StreamingMode.Seekable, new ReaderOptions());
var headers = new List<IRarHeader>();
foreach (var header in headerFactory.ReadHeaders(stream))
{
+ ct.ThrowIfCancellationRequested();
+
// we only care about file headers
if (header.HeaderType != HeaderType.File || header.IsDirectory() || header.GetFileName() == "QO") continue;
diff --git a/backend/Queue/QueueItemProcessor.cs b/backend/Queue/QueueItemProcessor.cs
index 353fab87..95a21077 100644
--- a/backend/Queue/QueueItemProcessor.cs
+++ b/backend/Queue/QueueItemProcessor.cs
@@ -42,6 +42,14 @@ public class QueueItemProcessor(
await ProcessQueueItemAsync(startTime);
}
+ // When a queue-item is removed while processing,
+ // then we need to clear any db changes and finish early.
+ catch (Exception e) when (e.GetBaseException() is OperationCanceledException or TaskCanceledException)
+ {
+ Log.Information($"Processing of queue item `{queueItem.JobName}` was cancelled.");
+ dbClient.Ctx.ChangeTracker.Clear();
+ }
+
// when non-retryable errors are encountered
// we must still remove the queue-item and add
// it to the history as a failed job.
diff --git a/backend/Queue/QueueManager.cs b/backend/Queue/QueueManager.cs
index cd368444..e755cac1 100644
--- a/backend/Queue/QueueManager.cs
+++ b/backend/Queue/QueueManager.cs
@@ -45,6 +45,7 @@ public class QueueManager : IDisposable
{
await _inProgressQueueItem.CancellationTokenSource.CancelAsync();
await _inProgressQueueItem.ProcessingTask;
+ _inProgressQueueItem = null;
}
await dbClient.RemoveQueueItemAsync(queueItemId);
@@ -78,18 +79,15 @@ public class QueueManager : IDisposable
);
});
await (_inProgressQueueItem?.ProcessingTask ?? Task.CompletedTask);
- await LockAsync(() => { _inProgressQueueItem = null; });
- }
- catch (OperationCanceledException)
- {
- // When the DeleteQueueItemAsync is called and the queue-item is currently
- // being processed, we explicitly cancel the processing of the queue-item.
- // Since this is expected API behavior, we can ignore this exception.
}
catch (Exception e)
{
Log.Error($"An unexpected error occured while processing the queue: {e.Message}");
}
+ finally
+ {
+ await LockAsync(() => { _inProgressQueueItem = null; });
+ }
}
}
diff --git a/backend/Streams/CancellableStream.cs b/backend/Streams/CancellableStream.cs
new file mode 100644
index 00000000..d05e5da2
--- /dev/null
+++ b/backend/Streams/CancellableStream.cs
@@ -0,0 +1,95 @@
+namespace NzbWebDAV.Streams;
+
+public class CancellableStream(Stream innerStream, CancellationToken token) : Stream
+{
+ private readonly Stream _innerStream = innerStream ?? throw new ArgumentNullException(nameof(innerStream));
+ private bool _disposed;
+
+ public override bool CanRead => _innerStream.CanRead;
+ public override bool CanSeek => _innerStream.CanSeek;
+ public override bool CanWrite => _innerStream.CanWrite;
+ public override long Length => _innerStream.Length;
+
+ public override long Position
+ {
+ get => _innerStream.Position;
+ set => _innerStream.Position = value;
+ }
+
+ public override void Flush()
+ {
+ CheckDisposed();
+ _innerStream.Flush();
+ }
+
+ public override Task FlushAsync(CancellationToken cancellationToken)
+ {
+ CheckDisposed();
+ return _innerStream.FlushAsync(cancellationToken);
+ }
+
+ public override int Read(byte[] buffer, int offset, int count)
+ {
+ CheckDisposed();
+ return ReadAsync(buffer, offset, count, token).Result;
+ }
+
+ public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default)
+ {
+ CheckDisposed();
+ return _innerStream.ReadAsync(buffer, cancellationToken);
+ }
+
+ public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+ {
+ CheckDisposed();
+ return _innerStream.ReadAsync(buffer, offset, count, cancellationToken);
+ }
+
+ public override void SetLength(long value)
+ {
+ CheckDisposed();
+ _innerStream.SetLength(value);
+ }
+
+ public override long Seek(long offset, SeekOrigin origin)
+ {
+ CheckDisposed();
+ return _innerStream.Seek(offset, origin);
+ }
+
+ public override void Write(byte[] buffer, int offset, int count)
+ {
+ CheckDisposed();
+ _innerStream.Write(buffer, offset, count);
+ }
+
+ public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+ {
+ CheckDisposed();
+ return _innerStream.WriteAsync(buffer, offset, count, cancellationToken);
+ }
+
+ public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default)
+ {
+ CheckDisposed();
+ return _innerStream.WriteAsync(buffer, cancellationToken);
+ }
+
+ private void CheckDisposed()
+ {
+ if (_disposed)
+ {
+ throw new ObjectDisposedException(nameof(CancellableStream));
+ }
+ }
+
+ protected override void Dispose(bool disposing)
+ {
+ if (_disposed) return;
+ if (!disposing) return;
+ _disposed = true;
+ _innerStream.Dispose();
+ base.Dispose();
+ }
+}
\ No newline at end of file