Implement YouTube SOCKS5 proxy

Meyn · Meyn · commit b0f694277a57 · 2025-08-03T14:17:58.000+02:00
diff --git a/Submodules/SessionGenerator b/Submodules/SessionGenerator
@@ -1 +1 @@
-Subproject commit 5fc7754fc04385c470512ee9b3a032f442e2bd6a
+Subproject commit 277505dad7dde7e7ec1c822d0f57a2b536298bc7
diff --git a/Tubifarry/Core/Model/AudioMetadataHandler.cs b/Tubifarry/Core/Model/AudioMetadataHandler.cs
@@ -245,6 +245,7 @@ public async Task<bool> TryExtractAudioFromVideoAsync()
 
                 File.Move(tempOutputPath, finalOutputPath, true);
                 TrackPath = finalOutputPath;
+                await EnsureFileExtAsync();
 
                 _logger?.Trace($"Successfully extracted audio to {Path.GetFileName(TrackPath)}");
                 return true;
diff --git a/Tubifarry/Core/Utilities/TrustedSessionHelper.cs b/Tubifarry/Core/Utilities/TrustedSessionHelper.cs
@@ -20,6 +20,8 @@ public class TrustedSessionHelper
         private static readonly Logger _logger = NzbDroneLogger.GetLogger(typeof(TrustedSessionHelper));
 
         private static SessionTokens? _cachedTokens;
+        private static bool? _nodeJsAvailable;
+        private static object _nodeJsCheckLock = new();
         private static readonly SemaphoreSlim _semaphore = new(1, 1);
 
         // Constants for retry logic
@@ -41,14 +43,14 @@ public static async Task<SessionTokens> GetTrustedSessionTokensAsync(string? ser
                     return _cachedTokens;
                 }
 
-                SessionTokens newTokens;
+                SessionTokens newTokens = new("", "", DateTime.UtcNow.AddHours(12));
 
                 if (!string.IsNullOrEmpty(serviceUrl))
                 {
                     _logger.Trace($"Using web service approach with URL: {serviceUrl}");
                     newTokens = await GetTokensFromWebServiceAsync(serviceUrl, forceRefresh, token);
                 }
-                else
+                else if (IsNodeJsAvailable())
                 {
                     _logger.Trace("Using local YouTubeSessionGenerator");
                     newTokens = await GetTokensFromLocalGeneratorAsync(token);
@@ -301,25 +303,8 @@ private static SessionTokens ParseTokenResponse(string responseJson, string sour
         /// </summary>
         public static async Task ValidateAuthenticationSettingsAsync(string? trustedSessionGeneratorUrl = null, string? cookiePath = null)
         {
-            if (string.IsNullOrEmpty(trustedSessionGeneratorUrl) && string.IsNullOrEmpty(cookiePath))
-            {
-                NodeEnvironment? testEnv = null;
-                try
-                {
-                    testEnv = new NodeEnvironment();
-                    _logger.Trace("Node.js environment test successful");
-                }
-                catch (Exception ex)
-                {
-                    throw new ArgumentException($"Node.js environment is not available for local token generation: {ex.Message}");
-                }
-                finally
-                {
-                    testEnv?.Dispose();
-                }
-
-                return;
-            }
+            if (string.IsNullOrEmpty(trustedSessionGeneratorUrl) && !IsNodeJsAvailable())
+                _logger.Warn("Node.js environment is not available for local token generation.");
 
             if (!string.IsNullOrEmpty(trustedSessionGeneratorUrl))
             {
@@ -359,6 +344,37 @@ public static async Task ValidateAuthenticationSettingsAsync(string? trustedSess
             }
         }
 
+        /// <summary>
+        /// Checks if Node.js is available for local token generation
+        /// </summary>
+        private static bool IsNodeJsAvailable()
+        {
+            lock (_nodeJsCheckLock)
+            {
+                if (_nodeJsAvailable.HasValue)
+                    return _nodeJsAvailable.Value;
+                NodeEnvironment? testEnv = null;
+                try
+                {
+                    _logger.Trace("Checking Node.js availability...");
+                    testEnv = new();
+                    _nodeJsAvailable = true;
+                    _logger.Debug("Node.js environment is available for local token generation");
+                    return true;
+                }
+                catch (Exception ex)
+                {
+                    _nodeJsAvailable = false;
+                    _logger.Warn(ex, "Node.js environment is not available for local token generation: {Message}", ex.Message);
+                    return false;
+                }
+                finally
+                {
+                    testEnv?.Dispose();
+                }
+            }
+        }
+
         public static void ClearCache()
         {
             _cachedTokens = null;
diff --git a/Tubifarry/Download/Clients/YouTube/YouTubeAlbumRequest.cs b/Tubifarry/Download/Clients/YouTube/YouTubeAlbumRequest.cs
@@ -198,6 +198,7 @@ private void AddTrackDownloadRequests(AlbumInfo albumInfo, AlbumSong trackInfo,
         private async Task<bool> SongDownloadCompletedAsync(AlbumInfo albumInfo, AlbumSong trackInfo, LoadRequest req, CancellationToken token)
         {
             string trackPath = req.Destination;
+            await Task.Delay(100, token);
             if (!File.Exists(trackPath))
                 return false;
 
diff --git a/Tubifarry/Download/Clients/YouTube/YoutubeClient.cs b/Tubifarry/Download/Clients/YouTube/YoutubeClient.cs
@@ -58,7 +58,7 @@ protected override void Test(List<ValidationFailure> failures)
             {
                 TrustedSessionHelper.ValidateAuthenticationSettingsAsync(Settings.TrustedSessionGeneratorUrl, Settings.CookiePath).Wait();
                 SessionTokens session = TrustedSessionHelper.GetTrustedSessionTokensAsync(Settings.TrustedSessionGeneratorUrl, true).Result;
-                if (!session.IsValid)
+                if (!session.IsValid && !session.IsEmpty)
                     failures.Add(new ValidationFailure("TrustedSessionGeneratorUrl", "Failed to retrieve valid tokens from the session generator service"));
             }
             catch (Exception ex)
diff --git a/Tubifarry/Indexers/Spotify/TubifarryIndexer.cs b/Tubifarry/Indexers/Spotify/TubifarryIndexer.cs
@@ -54,7 +54,7 @@ protected override async Task Test(List<ValidationFailure> failures)
             {
                 await TrustedSessionHelper.ValidateAuthenticationSettingsAsync(Settings.TrustedSessionGeneratorUrl, Settings.CookiePath);
                 SessionTokens session = await TrustedSessionHelper.GetTrustedSessionTokensAsync(Settings.TrustedSessionGeneratorUrl, true);
-                if (!session.IsValid)
+                if (!session.IsValid && !session.IsEmpty)
                     failures.Add(new ValidationFailure("TrustedSessionGeneratorUrl", "Failed to retrieve valid tokens from the session generator service"));
             }
             catch (Exception ex)
diff --git a/Tubifarry/Indexers/Youtube/YoutubeIndexer.cs b/Tubifarry/Indexers/Youtube/YoutubeIndexer.cs
@@ -50,7 +50,7 @@ protected override async Task Test(List<ValidationFailure> failures)
             {
                 await TrustedSessionHelper.ValidateAuthenticationSettingsAsync(Settings.TrustedSessionGeneratorUrl, Settings.CookiePath);
                 SessionTokens session = await TrustedSessionHelper.GetTrustedSessionTokensAsync(Settings.TrustedSessionGeneratorUrl, true);
-                if (!session.IsValid)
+                if (!session.IsValid && !session.IsEmpty)
                     failures.Add(new ValidationFailure("TrustedSessionGeneratorUrl", "Failed to retrieve valid tokens from the session generator service"));
             }
             catch (Exception ex)
diff --git a/Tubifarry/Notifications/QueueCleaner/ImportFailureNotificationService.cs b/Tubifarry/Notifications/QueueCleaner/ImportFailureNotificationService.cs
diff --git a/Tubifarry/Notifications/QueueCleaner/QueueCleaner.cs b/Tubifarry/Notifications/QueueCleaner/QueueCleaner.cs
@@ -56,9 +56,7 @@ internal void CleanImport(AlbumImportIncompleteEvent message)
             if (!trackedDownload.IsTrackable || trackedDownload.State != TrackedDownloadState.ImportFailed || !trackedDownload.DownloadItem.CanMoveFiles)
                 return;
 
-            ImportFailureReason failureReason = CheckImport(trackedDownload);
-
-            switch (failureReason)
+            switch (CheckImport(trackedDownload))
             {
                 case ImportFailureReason.FailedBecauseOfMissingTracks:
                     HandleFailure(trackedDownload, Settings.ImportCleaningOption, ImportCleaningOptions.WhenMissingTracks);
@@ -101,8 +99,7 @@ private void Remove(TrackedDownload item)
         {
             if (!item.DownloadItem.CanBeRemoved)
                 return;
-            List<IFileInfo> filesOnDisk = _diskProvider.GetFileInfos(item.DownloadItem.OutputPath.FullPath, true);
-            foreach (IFileInfo file in filesOnDisk)
+            foreach (IFileInfo file in (List<IFileInfo>)_diskProvider.GetFileInfos(item.DownloadItem.OutputPath.FullPath, true))
                 _diskProvider.DeleteFile(file.FullName);
             _eventAggregator.PublishEvent(new DownloadCanBeRemovedEvent(item));
         }
diff --git a/Tubifarry/Notifications/QueueCleaner/QueueCleanerSettings.cs b/Tubifarry/Notifications/QueueCleaner/QueueCleanerSettings.cs
diff --git a/Tubifarry/Notifications/YouTubeProxy/YouTubeProxyNotification.cs b/Tubifarry/Notifications/YouTubeProxy/YouTubeProxyNotification.cs
@@ -0,0 +1,18 @@
+﻿using FluentValidation.Results;
+using NzbDrone.Core.Notifications;
+using NzbDrone.Core.ThingiProvider;
+
+namespace Tubifarry.Notifications.YouTubeProxy
+{
+    public class YouTubeProxyNotification : NotificationBase<YouTubeProxySettings>
+    {
+        public override string Name => "YouTube Proxy";
+
+        public override string Link => "";
+
+        public override ProviderMessage Message => new("YouTube Proxy configures SOCKS5 proxy settings for HTTP requests. Configure your shadowsocks proxy details to route traffic through the specified server.", ProviderMessageType.Info);
+
+        public override ValidationResult Test() => new();
+        public override void OnGrab(GrabMessage message) { }
+    }
+}
diff --git a/Tubifarry/Notifications/YouTubeProxy/YouTubeProxyService.cs b/Tubifarry/Notifications/YouTubeProxy/YouTubeProxyService.cs
@@ -0,0 +1,107 @@
+﻿using DownloadAssistant.Base;
+using NLog;
+using NzbDrone.Core.Lifecycle;
+using NzbDrone.Core.Messaging.Events;
+using NzbDrone.Core.Notifications;
+using System.Net;
+using System.Net.Security;
+using System.Security.Authentication;
+
+namespace Tubifarry.Notifications.YouTubeProxy
+{
+    public class YouTubeProxyService : IHandle<ApplicationStartedEvent>
+    {
+        private readonly INotificationFactory _notificationFactory;
+        private readonly INotificationStatusService _notificationStatusService;
+        private readonly Logger _logger;
+
+        public YouTubeProxyService(INotificationFactory notificationFactory, INotificationStatusService notificationStatusService, Logger logger)
+        {
+            _notificationFactory = notificationFactory;
+            _notificationStatusService = notificationStatusService;
+            _logger = logger;
+        }
+
+        public void Handle(ApplicationStartedEvent message)
+        {
+            try
+            {
+                ConfigureProxySettings();
+            }
+            catch (Exception ex)
+            {
+                _logger.Error(ex, "Failed to configure proxy settings on application startup");
+            }
+        }
+
+        private void ConfigureProxySettings()
+        {
+            foreach (INotification? notification in (List<INotification>)_notificationFactory.GetAvailableProviders())
+            {
+                if (notification is not YouTubeProxyNotification proxyNotification)
+                    continue;
+
+                if (notification.Definition is not NotificationDefinition definition || !definition.Enable)
+                {
+                    _logger.Debug("YouTubeProxy notification is disabled, skipping proxy configuration");
+                    continue;
+                }
+
+                YouTubeProxySettings settings = (YouTubeProxySettings)proxyNotification.Definition.Settings;
+
+                try
+                {
+                    ConfigureHttpClientWithProxy(settings);
+                    _notificationStatusService.RecordSuccess(notification.Definition.Id);
+                    _logger.Info("Successfully configured HTTP client with SOCKS5 proxy: {0}:{1}", settings.ProxyHost, settings.ProxyPort);
+                }
+                catch (Exception ex)
+                {
+                    _notificationStatusService.RecordFailure(notification.Definition.Id);
+                    _logger.Error(ex, "Failed to configure HTTP client with proxy settings");
+                }
+            }
+        }
+
+        private void ConfigureHttpClientWithProxy(YouTubeProxySettings settings)
+        {
+            _logger.Info("Configuring HTTP client with SOCKS5 proxy: {0}:{1}", settings.ProxyHost, settings.ProxyPort);
+
+            WebProxy proxy;
+            if (settings.RequireAuthentication && !string.IsNullOrWhiteSpace(settings.Username))
+            {
+                proxy = new WebProxy($"socks5://{settings.ProxyHost}:{settings.ProxyPort}")
+                {
+                    Credentials = new NetworkCredential(settings.Username, settings.Password)
+                };
+                _logger.Debug("Proxy configured with authentication for user: {0}", settings.Username);
+            }
+            else
+            {
+                proxy = new WebProxy($"socks5://{settings.ProxyHost}:{settings.ProxyPort}");
+                _logger.Debug("Proxy configured without authentication");
+            }
+
+            SocketsHttpHandler handler = new()
+            {
+                Proxy = proxy,
+                UseProxy = true,
+                PooledConnectionLifetime = TimeSpan.FromMinutes(10),
+                PooledConnectionIdleTimeout = TimeSpan.FromMinutes(5),
+                MaxConnectionsPerServer = 10,
+                SslOptions = new SslClientAuthenticationOptions { EnabledSslProtocols = SslProtocols.Tls12 | SslProtocols.Tls13 }
+            };
+
+            HttpClient client = new(handler, disposeHandler: true) { Timeout = TimeSpan.FromSeconds(100) };
+            try
+            {
+                client.DefaultRequestHeaders.UserAgent.ParseAdd(UserAgentBuilder.Generate());
+            }
+            catch (Exception ex)
+            {
+                _logger.Warn(ex, "Failed to set user agent header, continuing without it");
+            }
+            HttpGet.HttpClient = client;
+        }
+    }
+}
diff --git a/Tubifarry/Notifications/YouTubeProxy/YouTubeProxySettings.cs b/Tubifarry/Notifications/YouTubeProxy/YouTubeProxySettings.cs
@@ -0,0 +1,54 @@
+﻿using FluentValidation;
+using NzbDrone.Core.Annotations;
+using NzbDrone.Core.ThingiProvider;
+using NzbDrone.Core.Validation;
+
+namespace Tubifarry.Notifications.YouTubeProxy
+{
+    public class YouTubeProxySettingsValidator : AbstractValidator<YouTubeProxySettings>
+    {
+        public YouTubeProxySettingsValidator()
+        {
+            RuleFor(c => c.ProxyHost)
+                .NotEmpty()
+                .WithMessage("Proxy host is required when proxy is enabled");
+
+            RuleFor(c => c.ProxyPort)
+                .GreaterThan(0)
+                .LessThanOrEqualTo(65535)
+                .WithMessage("Proxy port must be between 1 and 65535");
+
+            RuleFor(c => c.Username)
+                .NotEmpty()
+                .When(c => c.RequireAuthentication)
+                .WithMessage("Username is required when authentication is enabled");
+
+            RuleFor(c => c.Password)
+                .NotEmpty()
+                .When(c => c.RequireAuthentication)
+                .WithMessage("Password is required when authentication is enabled");
+        }
+    }
+
+    public class YouTubeProxySettings : IProviderConfig
+    {
+        private static readonly YouTubeProxySettingsValidator Validator = new();
+
+        [FieldDefinition(1, Label = "Proxy Host", Type = FieldType.Textbox, HelpText = "The hostname or IP address of your SOCKS5 proxy server.")]
+        public string ProxyHost { get; set; } = "";
+
+        [FieldDefinition(2, Label = "Proxy Port", Type = FieldType.Number, HelpText = "The port number of your SOCKS5 proxy server (typically 1080).")]
+        public int ProxyPort { get; set; } = 1080;
+
+        [FieldDefinition(3, Label = "Require Authentication", Type = FieldType.Checkbox, HelpText = "Enable if your SOCKS5 proxy requires username and password authentication.")]
+        public bool RequireAuthentication { get; set; }
+
+        [FieldDefinition(4, Label = "Username", Type = FieldType.Textbox, HelpText = "Username for proxy authentication (only required if authentication is enabled).")]
+        public string Username { get; set; } = "";
+
+        [FieldDefinition(5, Label = "Password", Type = FieldType.Password, HelpText = "Password for proxy authentication (only required if authentication is enabled).")]
+        public string Password { get; set; } = "";
+
+        public NzbDroneValidationResult Validate() => new(Validator.Validate(this));
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -198,6 +198,7 @@ private void AddTrackDownloadRequests(AlbumInfo albumInfo, AlbumSong trackInfo,`
`198`	`198`	`private async Task<bool> SongDownloadCompletedAsync(AlbumInfo albumInfo, AlbumSong trackInfo, LoadRequest req, CancellationToken token)`
`199`	`199`	`{`
`200`	`200`	`string trackPath = req.Destination;`
	`201`	`+ await Task.Delay(100, token);`
`201`	`202`	`if (!File.Exists(trackPath))`
`202`	`203`	`return false;`
`203`	`204`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ protected override void Test(List<ValidationFailure> failures)`
`58`	`58`	`{`
`59`	`59`	`TrustedSessionHelper.ValidateAuthenticationSettingsAsync(Settings.TrustedSessionGeneratorUrl, Settings.CookiePath).Wait();`
`60`	`60`	`SessionTokens session = TrustedSessionHelper.GetTrustedSessionTokensAsync(Settings.TrustedSessionGeneratorUrl, true).Result;`
`61`		`- if (!session.IsValid)`
	`61`	`+ if (!session.IsValid && !session.IsEmpty)`
`62`	`62`	`failures.Add(new ValidationFailure("TrustedSessionGeneratorUrl", "Failed to retrieve valid tokens from the session generator service"));`
`63`	`63`	`}`
`64`	`64`	`catch (Exception ex)`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ protected override async Task Test(List<ValidationFailure> failures)`
`54`	`54`	`{`
`55`	`55`	`await TrustedSessionHelper.ValidateAuthenticationSettingsAsync(Settings.TrustedSessionGeneratorUrl, Settings.CookiePath);`
`56`	`56`	`SessionTokens session = await TrustedSessionHelper.GetTrustedSessionTokensAsync(Settings.TrustedSessionGeneratorUrl, true);`
`57`		`- if (!session.IsValid)`
	`57`	`+ if (!session.IsValid && !session.IsEmpty)`
`58`	`58`	`failures.Add(new ValidationFailure("TrustedSessionGeneratorUrl", "Failed to retrieve valid tokens from the session generator service"));`
`59`	`59`	`}`
`60`	`60`	`catch (Exception ex)`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ protected override async Task Test(List<ValidationFailure> failures)`
`50`	`50`	`{`
`51`	`51`	`await TrustedSessionHelper.ValidateAuthenticationSettingsAsync(Settings.TrustedSessionGeneratorUrl, Settings.CookiePath);`
`52`	`52`	`SessionTokens session = await TrustedSessionHelper.GetTrustedSessionTokensAsync(Settings.TrustedSessionGeneratorUrl, true);`
`53`		`- if (!session.IsValid)`
	`53`	`+ if (!session.IsValid && !session.IsEmpty)`
`54`	`54`	`failures.Add(new ValidationFailure("TrustedSessionGeneratorUrl", "Failed to retrieve valid tokens from the session generator service"));`
`55`	`55`	`}`
`56`	`56`	`catch (Exception ex)`
Original file line number	Diff line number	Diff line change
`@@ -56,9 +56,7 @@ internal void CleanImport(AlbumImportIncompleteEvent message)`
`56`	`56`	`if (!trackedDownload.IsTrackable \|\| trackedDownload.State != TrackedDownloadState.ImportFailed \|\| !trackedDownload.DownloadItem.CanMoveFiles)`
`57`	`57`	`return;`
`58`	`58`
`59`		`- ImportFailureReason failureReason = CheckImport(trackedDownload);`
`60`		`-`
`61`		`- switch (failureReason)`
	`59`	`+ switch (CheckImport(trackedDownload))`
`62`	`60`	`{`
`63`	`61`	`case ImportFailureReason.FailedBecauseOfMissingTracks:`
`64`	`62`	`HandleFailure(trackedDownload, Settings.ImportCleaningOption, ImportCleaningOptions.WhenMissingTracks);`
`@@ -101,8 +99,7 @@ private void Remove(TrackedDownload item)`
`101`	`99`	`{`
`102`	`100`	`if (!item.DownloadItem.CanBeRemoved)`
`103`	`101`	`return;`
`104`		`- List<IFileInfo> filesOnDisk = _diskProvider.GetFileInfos(item.DownloadItem.OutputPath.FullPath, true);`
`105`		`- foreach (IFileInfo file in filesOnDisk)`
	`102`	`+ foreach (IFileInfo file in (List<IFileInfo>)_diskProvider.GetFileInfos(item.DownloadItem.OutputPath.FullPath, true))`
`106`	`103`	`_diskProvider.DeleteFile(file.FullName);`
`107`	`104`	`_eventAggregator.PublishEvent(new DownloadCanBeRemovedEvent(item));`
`108`	`105`	`}`