Added the ability to refresh out backend metadata

src/Ombi.Api/Api.cs

@@ -1,11 +1,15 @@
-using System.IO;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Threading.Tasks;
 using System.Xml.Serialization;
 using Newtonsoft.Json;
 using Microsoft.Extensions.Logging;
 using Ombi.Helpers;
+using Polly;
 
 namespace Ombi.Api
 {
@@ -36,6 +40,30 @@ public async Task<T> Request<T>(Request request)
                 if (!httpResponseMessage.IsSuccessStatusCode)
                 {
                     LogError(request, httpResponseMessage);
+                    if (request.Retry)
+                    {
+
+                        var result = Policy
+                            .Handle<HttpRequestException>()
+                            .OrResult<HttpResponseMessage>(r => request.StatusCodeToRetry.Contains(r.StatusCode))
+                            .WaitAndRetryAsync(new[]
+                            {
+                                TimeSpan.FromSeconds(10),
+                            }, (exception, timeSpan, context) =>
+                            {
+
+                                Logger.LogError(LoggingEvents.Api,
+                                    $"Retrying RequestUri: {request.FullUri} Because we got Status Code: {exception?.Result?.StatusCode}");
+                            });
+
+                        httpResponseMessage = await result.ExecuteAsync(async () =>
+                        {
+                            using (var req = await httpRequestMessage.Clone())
+                            {
+                                return await _client.SendAsync(req);
+                            }
+                        });
+                    }
                 }
 
                 // do something with the response

src/Ombi.Api/HttpRequestExtnesions.cs

@@ -0,0 +1,45 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Net.Http;
+using System.Threading.Tasks;
+
+namespace Ombi.Api
+{
+    public static class HttpRequestExtnesions
+    {
+        public static async Task<HttpRequestMessage> Clone(this HttpRequestMessage request)
+        {
+            var clone = new HttpRequestMessage(request.Method, request.RequestUri)
+            {
+                Content = await request.Content.Clone(),
+                Version = request.Version
+            };
+            foreach (KeyValuePair<string, object> prop in request.Properties)
+            {
+                clone.Properties.Add(prop);
+            }
+            foreach (KeyValuePair<string, IEnumerable<string>> header in request.Headers)
+            {
+                clone.Headers.TryAddWithoutValidation(header.Key, header.Value);
+            }
+
+            return clone;
+        }
+
+        public static async Task<HttpContent> Clone(this HttpContent content)
+        {
+            if (content == null) return null;
+
+            var ms = new MemoryStream();
+            await content.CopyToAsync(ms);
+            ms.Position = 0;
+
+            var clone = new StreamContent(ms);
+            foreach (KeyValuePair<string, IEnumerable<string>> header in content.Headers)
+            {
+                clone.Headers.Add(header.Key, header.Value);
+            }
+            return clone;
+        }
+    }
+}

src/Ombi.Api/Ombi.Api.csproj

@@ -11,6 +11,7 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="2.0.0" />
     <PackageReference Include="Newtonsoft.Json" Version="10.0.3" />
+    <PackageReference Include="Polly" Version="5.8.0" />
     <PackageReference Include="System.Xml.XmlSerializer" Version="4.3.0" />
   </ItemGroup>
 

src/Ombi.Api/Request.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Net;
 using System.Net.Http;
 using System.Text;
 
@@ -25,6 +26,9 @@ public Request(string endpoint, string baseUrl, HttpMethod http, ContentType con
         public string BaseUrl { get; }
         public HttpMethod HttpMethod { get; }
 
+        public bool Retry { get; set; }
+        public List<HttpStatusCode> StatusCodeToRetry { get; set; } = new List<HttpStatusCode>();
+
         public Action<string> OnBeforeDeserialization { get; set; }
 
         private string FullUrl

src/Ombi.DependencyInjection/IocExtensions.cs

@@ -172,6 +172,7 @@ public static void RegisterJobs(this IServiceCollection services)
             services.AddTransient<ICouchPotatoSync, CouchPotatoSync>();
             services.AddTransient<IProcessProvider, ProcessProvider>();
             services.AddTransient<ISickRageSync, SickRageSync>();
+            services.AddTransient<IRefreshMetadata, RefreshMetadata>();
         }
     }
 }

src/Ombi.Schedule/JobSetup.cs

@@ -17,46 +17,49 @@ public class JobSetup : IJobSetup
         public JobSetup(IPlexContentSync plexContentSync, IRadarrSync radarrSync,
             IOmbiAutomaticUpdater updater, IEmbyContentSync embySync, IPlexUserImporter userImporter,
             IEmbyUserImporter embyUserImporter, ISonarrSync cache, ICouchPotatoSync cpCache,
-            ISettingsService<JobSettings> jobsettings, ISickRageSync srSync)
+            ISettingsService<JobSettings> jobsettings, ISickRageSync srSync, IRefreshMetadata refresh)
         {
-            PlexContentSync = plexContentSync;
-            RadarrSync = radarrSync;
-            Updater = updater;
-            EmbyContentSync = embySync;
-            PlexUserImporter = userImporter;
-            EmbyUserImporter = embyUserImporter;
-            SonarrSync = cache;
-            CpCache = cpCache;
-            JobSettings = jobsettings;
-            SrSync = srSync;
+            _plexContentSync = plexContentSync;
+            _radarrSync = radarrSync;
+            _updater = updater;
+            _embyContentSync = embySync;
+            _plexUserImporter = userImporter;
+            _embyUserImporter = embyUserImporter;
+            _sonarrSync = cache;
+            _cpCache = cpCache;
+            _jobSettings = jobsettings;
+            _srSync = srSync;
+            _refreshMetadata = refresh;
         }
 
-        private IPlexContentSync PlexContentSync { get; }
-        private IRadarrSync RadarrSync { get; }
-        private IOmbiAutomaticUpdater Updater { get; }
-        private IPlexUserImporter PlexUserImporter { get; }
-        private IEmbyContentSync EmbyContentSync { get; }
-        private IEmbyUserImporter EmbyUserImporter { get; }
-        private ISonarrSync SonarrSync { get; }
-        private ICouchPotatoSync CpCache { get; }
-        private ISickRageSync SrSync { get; }
-        private ISettingsService<JobSettings> JobSettings { get; set; }
+        private readonly IPlexContentSync _plexContentSync;
+        private readonly IRadarrSync _radarrSync;
+        private readonly IOmbiAutomaticUpdater _updater;
+        private readonly IPlexUserImporter _plexUserImporter;
+        private readonly IEmbyContentSync _embyContentSync;
+        private readonly IEmbyUserImporter _embyUserImporter;
+        private readonly ISonarrSync _sonarrSync;
+        private readonly ICouchPotatoSync _cpCache;
+        private readonly ISickRageSync _srSync;
+        private readonly ISettingsService<JobSettings> _jobSettings;
+        private readonly IRefreshMetadata _refreshMetadata;
 
         public void Setup()
         {
-            var s = JobSettings.GetSettings();
+            var s = _jobSettings.GetSettings();
 
-            RecurringJob.AddOrUpdate(() => EmbyContentSync.Start(), JobSettingsHelper.EmbyContent(s));
-            RecurringJob.AddOrUpdate(() => SonarrSync.Start(), JobSettingsHelper.Sonarr(s));
-            RecurringJob.AddOrUpdate(() => RadarrSync.CacheContent(), JobSettingsHelper.Radarr(s));
-            RecurringJob.AddOrUpdate(() => PlexContentSync.CacheContent(), JobSettingsHelper.PlexContent(s));
-            RecurringJob.AddOrUpdate(() => CpCache.Start(), JobSettingsHelper.CouchPotato(s));
-            RecurringJob.AddOrUpdate(() => SrSync.Start(), JobSettingsHelper.SickRageSync(s));
+            RecurringJob.AddOrUpdate(() => _embyContentSync.Start(), JobSettingsHelper.EmbyContent(s));
+            RecurringJob.AddOrUpdate(() => _sonarrSync.Start(), JobSettingsHelper.Sonarr(s));
+            RecurringJob.AddOrUpdate(() => _radarrSync.CacheContent(), JobSettingsHelper.Radarr(s));
+            RecurringJob.AddOrUpdate(() => _plexContentSync.CacheContent(), JobSettingsHelper.PlexContent(s));
+            RecurringJob.AddOrUpdate(() => _cpCache.Start(), JobSettingsHelper.CouchPotato(s));
+            RecurringJob.AddOrUpdate(() => _srSync.Start(), JobSettingsHelper.SickRageSync(s));
+            RecurringJob.AddOrUpdate(() => _refreshMetadata.Start(), JobSettingsHelper.RefreshMetadata(s));
 
-            RecurringJob.AddOrUpdate(() => Updater.Update(null), JobSettingsHelper.Updater(s));
+            RecurringJob.AddOrUpdate(() => _updater.Update(null), JobSettingsHelper.Updater(s));
 
-            RecurringJob.AddOrUpdate(() => EmbyUserImporter.Start(), JobSettingsHelper.UserImporter(s));
-            RecurringJob.AddOrUpdate(() => PlexUserImporter.Start(), JobSettingsHelper.UserImporter(s));
+            RecurringJob.AddOrUpdate(() => _embyUserImporter.Start(), JobSettingsHelper.UserImporter(s));
+            RecurringJob.AddOrUpdate(() => _plexUserImporter.Start(), JobSettingsHelper.UserImporter(s));
         }
     }
 }

src/Ombi.Schedule/Jobs/Ombi/IRefreshMetadata.cs

@@ -0,0 +1,9 @@
+using System.Threading.Tasks;
+
+namespace Ombi.Schedule.Jobs.Ombi
+{
+    public interface IRefreshMetadata : IBaseJob
+    {
+        Task Start();
+    }
+}