Add analysers to Emby.IsoMounting and enable TreatWarningsAsErrors

Emby.IsoMounting/IsoMounter/Configuration/PluginConfiguration.cs

@@ -2,6 +2,9 @@ using MediaBrowser.Model.Plugins;
 
 namespace IsoMounter.Configuration
 {
+    /// <summary>
+    /// Class PluginConfiguration.
+    /// </summary>
     public class PluginConfiguration : BasePluginConfiguration
     {
     }

Emby.IsoMounting/IsoMounter/IsoMounter.csproj

@@ -13,6 +13,18 @@
     <TargetFramework>netstandard2.0</TargetFramework>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+  </PropertyGroup>
+
+  <!-- Code analysers-->
+  <ItemGroup Condition=" '$(Configuration)' == 'Debug' ">
+    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="2.9.4" />
+    <PackageReference Include="StyleCop.Analyzers" Version="1.1.118" />
+    <PackageReference Include="SerilogAnalyzer" Version="0.15.0" />
+  </ItemGroup>
+
+  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
+    <CodeAnalysisRuleSet>../../jellyfin.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
 
 </Project>

Emby.IsoMounting/IsoMounter/LinuxIsoManager.cs

@@ -1,9 +1,10 @@
 using System;
+using System.Diagnostics;
+using System.Globalization;
 using System.IO;
 using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
-using MediaBrowser.Model.Diagnostics;
 using MediaBrowser.Model.IO;
 using MediaBrowser.Model.System;
 using Microsoft.Extensions.Logging;
@@ -11,441 +12,274 @@ using OperatingSystem = MediaBrowser.Common.System.OperatingSystem;
 
 namespace IsoMounter
 {
+    /// <summary>
+    /// The ISO manager implementation for Linux.
+    /// </summary>
     public class LinuxIsoManager : IIsoMounter
     {
-        [DllImport("libc", SetLastError = true)]
-        static extern uint getuid();
+        private const string MountCommand = "mount";
+        private const string UnmountCommand = "umount";
+        private const string SudoCommand = "sudo";
 
-        #region Private Fields
-
-        private readonly bool ExecutablesAvailable;
         private readonly ILogger _logger;
-        private readonly string MountCommand;
-        private readonly string MountPointRoot;
-        private readonly IProcessFactory ProcessFactory;
-        private readonly string SudoCommand;
-        private readonly string UmountCommand;
-
-        #endregion
+        private readonly string _mountPointRoot;
 
-        #region Constructor(s)
-
-        public LinuxIsoManager(ILogger logger, IProcessFactory processFactory)
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LinuxIsoManager" /> class.
+        /// </summary>
+        /// <param name="logger">The logger.</param>
+        public LinuxIsoManager(ILogger logger)
         {
             _logger = logger;
-            ProcessFactory = processFactory;
 
-            MountPointRoot = Path.DirectorySeparatorChar + "tmp" + Path.DirectorySeparatorChar + "Emby";
+            _mountPointRoot = Path.DirectorySeparatorChar + "tmp" + Path.DirectorySeparatorChar + "Emby";
 
             _logger.LogDebug(
                 "[{0}] System PATH is currently set to [{1}].",
                 Name,
-                Environment.GetEnvironmentVariable("PATH") ?? ""
-            );
+                Environment.GetEnvironmentVariable("PATH") ?? string.Empty);
 
             _logger.LogDebug(
                 "[{0}] System path separator is [{1}].",
                 Name,
-                Path.PathSeparator
-            );
+                Path.PathSeparator);
 
             _logger.LogDebug(
                 "[{0}] Mount point root is [{1}].",
                 Name,
-                MountPointRoot
-            );
-
-            //
-            // Get the location of the executables we need to support mounting/unmounting ISO images.
-            //
-
-            SudoCommand = GetFullPathForExecutable("sudo");
-
-            _logger.LogInformation(
-                "[{0}] Using version of [sudo] located at [{1}].",
-                Name,
-                SudoCommand
-            );
-
-            MountCommand = GetFullPathForExecutable("mount");
-
-            _logger.LogInformation(
-                "[{0}] Using version of [mount] located at [{1}].",
-                Name,
-                MountCommand
-            );
-
-            UmountCommand = GetFullPathForExecutable("umount");
-
-            _logger.LogInformation(
-                "[{0}] Using version of [umount] located at [{1}].",
-                Name,
-                UmountCommand
-            );
-
-            if (!string.IsNullOrEmpty(SudoCommand) && !string.IsNullOrEmpty(MountCommand) && !string.IsNullOrEmpty(UmountCommand))
-            {
-                ExecutablesAvailable = true;
-            }
-            else
-            {
-                ExecutablesAvailable = false;
-            }
-
+                _mountPointRoot);
         }
 
-        #endregion
-
-        #region Interface Implementation for IIsoMounter
-
-        public bool IsInstalled => true;
-
+        /// <inheritdoc />
         public string Name => "LinuxMount";
 
-        public bool RequiresInstallation => false;
+#pragma warning disable SA1300
+#pragma warning disable SA1400
+        [DllImport("libc", SetLastError = true)]
+        static extern uint getuid();
+
+#pragma warning restore SA1300
+#pragma warning restore SA1400
 
+        /// <inheritdoc />
         public bool CanMount(string path)
         {
-
             if (OperatingSystem.Id != OperatingSystemId.Linux)
             {
                 return false;
             }
+
             _logger.LogInformation(
-                "[{0}] Checking we can attempt to mount [{1}], Extension = [{2}], Operating System = [{3}], Executables Available = [{4}].",
+                "[{0}] Checking we can attempt to mount [{1}], Extension = [{2}], Operating System = [{3}].",
                 Name,
                 path,
                 Path.GetExtension(path),
-                OperatingSystem.Name,
-                ExecutablesAvailable
-            );
+                OperatingSystem.Name);
 
-            if (ExecutablesAvailable)
-            {
-                return string.Equals(Path.GetExtension(path), ".iso", StringComparison.OrdinalIgnoreCase);
-            }
-            else
-            {
-                return false;
-            }
-        }
-
-        public Task Install(CancellationToken cancellationToken)
-        {
-            return Task.FromResult(false);
+            return string.Equals(Path.GetExtension(path), ".iso", StringComparison.OrdinalIgnoreCase);
         }
 
+        /// <inheritdoc />
         public Task<IIsoMount> Mount(string isoPath, CancellationToken cancellationToken)
         {
-            if (MountISO(isoPath, out LinuxMount mountedISO))
-            {
-                return Task.FromResult<IIsoMount>(mountedISO);
-            }
-            else
+            string cmdArguments;
+            string cmdFilename;
+            string mountPoint = Path.Combine(_mountPointRoot, Guid.NewGuid().ToString());
+
+            if (string.IsNullOrEmpty(isoPath))
             {
-                throw new IOException(string.Format(
-                    "An error occurred trying to mount image [$0].",
-                    isoPath
-                ));
+                throw new ArgumentNullException(nameof(isoPath));
             }
-        }
 
-        #endregion
-
-        #region Interface Implementation for IDisposable
-
-        // Flag: Has Dispose already been called?
-        private bool disposed = false;
-
-        public void Dispose()
-        {
-
-            // Dispose of unmanaged resources.
-            Dispose(true);
-
-            // Suppress finalization.
-            GC.SuppressFinalize(this);
+            _logger.LogInformation(
+                "[{Name}] Attempting to mount [{Path}].",
+                Name,
+                isoPath);
 
-        }
+            _logger.LogDebug(
+                "[{Name}] ISO will be mounted at [{Path}].",
+                Name,
+                mountPoint);
 
-        protected virtual void Dispose(bool disposing)
-        {
+            try
+            {
+                Directory.CreateDirectory(mountPoint);
+            }
+            catch (UnauthorizedAccessException ex)
+            {
+                throw new IOException("Unable to create mount point(Permission denied) for " + isoPath, ex);
+            }
+            catch (Exception ex)
+            {
+                throw new IOException("Unable to create mount point for " + isoPath, ex);
+            }
 
-            if (disposed)
+            if (GetUID() == 0)
+            {
+                cmdFilename = MountCommand;
+                cmdArguments = string.Format(
+                    CultureInfo.InvariantCulture,
+                    "\"{0}\" \"{1}\"",
+                    isoPath,
+                    mountPoint);
+            }
+            else
             {
-                return;
+                cmdFilename = SudoCommand;
+                cmdArguments = string.Format(
+                    CultureInfo.InvariantCulture,
+                    "\"{0}\" \"{1}\" \"{2}\"",
+                    MountCommand,
+                    isoPath,
+                    mountPoint);
             }
 
-            _logger.LogInformation(
-                "[{0}] Disposing [{1}].",
+            _logger.LogDebug(
+                "[{0}] Mount command [{1}], mount arguments [{2}].",
                 Name,
-                disposing
-            );
+                cmdFilename,
+                cmdArguments);
 
-            if (disposing)
+            int exitcode = ExecuteCommand(cmdFilename, cmdArguments);
+            if (exitcode == 0)
             {
+                _logger.LogInformation(
+                    "[{0}] ISO mount completed successfully.",
+                    Name);
 
-                //
-                // Free managed objects here.
-                //
-
+                return Task.FromResult<IIsoMount>(new LinuxMount(this, isoPath, mountPoint));
             }
 
-            //
-            // Free any unmanaged objects here.
-            //
-
-            disposed = true;
-
-        }
-
-        #endregion
-
-        #region Private Methods
-
-        private string GetFullPathForExecutable(string name)
-        {
+            _logger.LogInformation(
+                "[{0}] ISO mount completed with errors.",
+                Name);
 
-            foreach (string test in (Environment.GetEnvironmentVariable("PATH") ?? "").Split(Path.PathSeparator))
+            try
             {
-                string path = test.Trim();
-
-                if (!string.IsNullOrEmpty(path) && File.Exists(path = Path.Combine(path, name)))
-                {
-                    return Path.GetFullPath(path);
-                }
+                Directory.Delete(mountPoint, false);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "[{Name}] Unhandled exception removing mount point.", Name);
+                throw;
             }
 
-            return string.Empty;
+            throw new ExternalException("Mount command failed", exitcode);
         }
 
         private uint GetUID()
         {
-
             var uid = getuid();
 
             _logger.LogDebug(
                 "[{0}] GetUserId() returned [{2}].",
                 Name,
-                uid
-            );
+                uid);
 
             return uid;
-
         }
 
-        private bool ExecuteCommand(string cmdFilename, string cmdArguments)
+        private int ExecuteCommand(string cmdFilename, string cmdArguments)
         {
-
-            bool processFailed = false;
-
-            var process = ProcessFactory.Create(
-                new ProcessOptions
-                {
-                    CreateNoWindow = true,
-                    RedirectStandardOutput = true,
-                    RedirectStandardError = true,
-                    UseShellExecute = false,
-                    FileName = cmdFilename,
-                    Arguments = cmdArguments,
-                    IsHidden = true,
-                    ErrorDialog = false,
-                    EnableRaisingEvents = true
-                }
-            );
+            var startInfo = new ProcessStartInfo
+            {
+                FileName = cmdFilename,
+                Arguments = cmdArguments,
+                UseShellExecute = false,
+                CreateNoWindow = true,
+                ErrorDialog = false,
+                RedirectStandardOutput = true,
+                RedirectStandardError = true
+            };
+
+            var process = new Process()
+            {
+                StartInfo = startInfo
+            };
 
             try
             {
                 process.Start();
 
-                //StreamReader outputReader = process.StandardOutput.;
-                //StreamReader errorReader = process.StandardError;
-
                 _logger.LogDebug(
                     "[{Name}] Standard output from process is [{Error}].",
                     Name,
-                    process.StandardOutput.ReadToEnd()
-                );
+                    process.StandardOutput.ReadToEnd());
 
                 _logger.LogDebug(
                     "[{Name}] Standard error from process is [{Error}].",
                     Name,
-                    process.StandardError.ReadToEnd()
-                );
+                    process.StandardError.ReadToEnd());
+
+                return process.ExitCode;
             }
             catch (Exception ex)
             {
-                processFailed = true;
                 _logger.LogDebug(ex, "[{Name}] Unhandled exception executing command.", Name);
+                throw;
             }
-
-            if (!processFailed && process.ExitCode == 0)
+            finally
             {
-                return true;
+                process?.Dispose();
             }
-            else
-            {
-                return false;
-            }
-
         }
 
-        private bool MountISO(string isoPath, out LinuxMount mountedISO)
+        /// <summary>
+        /// Unmounts the specified mount.
+        /// </summary>
+        /// <param name="mount">The mount.</param>
+        internal void OnUnmount(LinuxMount mount)
         {
-
-            string cmdArguments;
-            string cmdFilename;
-            string mountPoint = Path.Combine(MountPointRoot, Guid.NewGuid().ToString());
-
-            if (!string.IsNullOrEmpty(isoPath))
-            {
-
-                _logger.LogInformation(
-                    "[{Name}] Attempting to mount [{Path}].",
-                    Name,
-                    isoPath
-                );
-
-                _logger.LogDebug(
-                    "[{Name}] ISO will be mounted at [{Path}].",
-                    Name,
-                    mountPoint
-                );
-
-            }
-            else
+            if (mount == null)
             {
-
-                throw new ArgumentNullException(nameof(isoPath));
-
-            }
-
-            try
-            {
-                Directory.CreateDirectory(mountPoint);
-            }
-            catch (UnauthorizedAccessException)
-            {
-                throw new IOException("Unable to create mount point(Permission denied) for " + isoPath);
-            }
-            catch (Exception)
-            {
-                throw new IOException("Unable to create mount point for " + isoPath);
-            }
-
-            if (GetUID() == 0)
-            {
-                cmdFilename = MountCommand;
-                cmdArguments = string.Format("\"{0}\" \"{1}\"", isoPath, mountPoint);
-            }
-            else
-            {
-                cmdFilename = SudoCommand;
-                cmdArguments = string.Format("\"{0}\" \"{1}\" \"{2}\"", MountCommand, isoPath, mountPoint);
+                throw new ArgumentNullException(nameof(mount));
             }
 
-            _logger.LogDebug(
-                "[{0}] Mount command [{1}], mount arguments [{2}].",
+            _logger.LogInformation(
+                "[{0}] Attempting to unmount ISO [{1}] mounted on [{2}].",
                 Name,
-                cmdFilename,
-                cmdArguments
-            );
-
-            if (ExecuteCommand(cmdFilename, cmdArguments))
-            {
-
-                _logger.LogInformation(
-                    "[{0}] ISO mount completed successfully.",
-                    Name
-                );
-
-                mountedISO = new LinuxMount(this, isoPath, mountPoint);
-
-            }
-            else
-            {
-
-                _logger.LogInformation(
-                    "[{0}] ISO mount completed with errors.",
-                    Name
-                );
-
-                try
-                {
-                    Directory.Delete(mountPoint, false);
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogInformation(ex, "[{Name}] Unhandled exception removing mount point.", Name);
-                }
-
-                mountedISO = null;
-
-            }
-
-            return mountedISO != null;
-
-        }
-
-        private void UnmountISO(LinuxMount mount)
-        {
+                mount.IsoPath,
+                mount.MountedPath);
 
             string cmdArguments;
             string cmdFilename;
 
-            if (mount != null)
-            {
-
-                _logger.LogInformation(
-                    "[{0}] Attempting to unmount ISO [{1}] mounted on [{2}].",
-                    Name,
-                    mount.IsoPath,
-                    mount.MountedPath
-                );
-
-            }
-            else
-            {
-
-                throw new ArgumentNullException(nameof(mount));
-
-            }
-
             if (GetUID() == 0)
             {
-                cmdFilename = UmountCommand;
-                cmdArguments = string.Format("\"{0}\"", mount.MountedPath);
+                cmdFilename = UnmountCommand;
+                cmdArguments = string.Format(
+                    CultureInfo.InvariantCulture,
+                    "\"{0}\"",
+                    mount.MountedPath);
             }
             else
             {
                 cmdFilename = SudoCommand;
-                cmdArguments = string.Format("\"{0}\" \"{1}\"", UmountCommand, mount.MountedPath);
+                cmdArguments = string.Format(
+                    CultureInfo.InvariantCulture,
+                    "\"{0}\" \"{1}\"",
+                    UnmountCommand,
+                    mount.MountedPath);
             }
 
             _logger.LogDebug(
                 "[{0}] Umount command [{1}], umount arguments [{2}].",
                 Name,
                 cmdFilename,
-                cmdArguments
-            );
+                cmdArguments);
 
-            if (ExecuteCommand(cmdFilename, cmdArguments))
+            int exitcode = ExecuteCommand(cmdFilename, cmdArguments);
+            if (exitcode == 0)
             {
-
                 _logger.LogInformation(
                     "[{0}] ISO unmount completed successfully.",
-                    Name
-                );
-
+                    Name);
             }
             else
             {
-
                 _logger.LogInformation(
                     "[{0}] ISO unmount completed with errors.",
-                    Name
-                );
-
+                    Name);
             }
 
             try
@@ -454,24 +288,11 @@ namespace IsoMounter
             }
             catch (Exception ex)
             {
-                _logger.LogInformation(ex, "[{Name}] Unhandled exception removing mount point.", Name);
+                _logger.LogError(ex, "[{Name}] Unhandled exception removing mount point.", Name);
+                throw;
             }
-        }
-
-        #endregion
-
-        #region Internal Methods
-
-        internal void OnUnmount(LinuxMount mount)
-        {
-
-            UnmountISO(mount);
 
+            throw new ExternalException("Mount command failed", exitcode);
         }
-
-        #endregion
-
     }
-
 }
-

Emby.IsoMounting/IsoMounter/LinuxMount.cs

@@ -3,81 +3,56 @@ using MediaBrowser.Model.IO;
 
 namespace IsoMounter
 {
+    /// <summary>
+    /// Class LinuxMount.
+    /// </summary>
     internal class LinuxMount : IIsoMount
     {
+        private readonly LinuxIsoManager _linuxIsoManager;
 
-        #region Private Fields
-
-        private readonly LinuxIsoManager linuxIsoManager;
-
-        #endregion
-
-        #region Constructor(s)
+        private bool _disposed = false;
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LinuxMount" /> class.
+        /// </summary>
+        /// <param name="isoManager">The ISO manager that mounted this ISO file.</param>
+        /// <param name="isoPath">The path to the ISO file.</param>
+        /// <param name="mountFolder">The folder the ISO is mounted in.</param>
         internal LinuxMount(LinuxIsoManager isoManager, string isoPath, string mountFolder)
         {
-
-            linuxIsoManager = isoManager;
+            _linuxIsoManager = isoManager;
 
             IsoPath = isoPath;
             MountedPath = mountFolder;
-
         }
 
-        #endregion
-
-        #region Interface Implementation for IDisposable
+        /// <inheritdoc />
+        public string IsoPath { get; }
 
-        // Flag: Has Dispose already been called?
-        private bool disposed = false;
+        /// <inheritdoc />
+        public string MountedPath { get; }
 
+        /// <inheritdoc />
         public void Dispose()
         {
-
-            // Dispose of unmanaged resources.
             Dispose(true);
-
-            // Suppress finalization.
             GC.SuppressFinalize(this);
-
         }
 
+        /// <summary>
+        /// Releases the unmanaged resources and disposes of the managed resources used.
+        /// </summary>
+        /// <param name="disposing">Whether or not the managed resources should be disposed.</param>
         protected virtual void Dispose(bool disposing)
         {
-
-            if (disposed)
+            if (_disposed)
             {
                 return;
             }
 
-            if (disposing)
-            {
-
-                //
-                // Free managed objects here.
-                //
-
-                linuxIsoManager.OnUnmount(this);
-
-            }
-
-            //
-            // Free any unmanaged objects here.
-            //
-
-            disposed = true;
+            _linuxIsoManager.OnUnmount(this);
 
+            _disposed = true;
         }
-
-        #endregion
-
-        #region Interface Implementation for IIsoMount
-
-        public string IsoPath { get; private set; }
-        public string MountedPath { get; private set; }
-
-        #endregion
-
     }
-
 }

Emby.IsoMounting/IsoMounter/Plugin.cs

@@ -6,25 +6,28 @@ using MediaBrowser.Model.Serialization;
 
 namespace IsoMounter
 {
+    /// <summary>
+    /// The LinuxMount plugin class.
+    /// </summary>
     public class Plugin : BasePlugin<PluginConfiguration>
     {
-        public Plugin(IApplicationPaths applicationPaths, IXmlSerializer xmlSerializer) : base(applicationPaths, xmlSerializer)
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Plugin" /> class.
+        /// </summary>
+        /// <param name="applicationPaths">The application paths.</param>
+        /// <param name="xmlSerializer">The XML serializer.</param>
+        public Plugin(IApplicationPaths applicationPaths, IXmlSerializer xmlSerializer)
+            : base(applicationPaths, xmlSerializer)
         {
         }
 
-        private Guid _id = new Guid("4682DD4C-A675-4F1B-8E7C-79ADF137A8F8");
-        public override Guid Id => _id;
+        /// <inheritdoc />
+        public override Guid Id { get; } = new Guid("4682DD4C-A675-4F1B-8E7C-79ADF137A8F8");
 
-        /// <summary>
-        /// Gets the name of the plugin
-        /// </summary>
-        /// <value>The name.</value>
+        /// <inheritdoc />
         public override string Name => "Iso Mounter";
 
-        /// <summary>
-        /// Gets the description.
-        /// </summary>
-        /// <value>The description.</value>
+        /// <inheritdoc />
         public override string Description => "Mount and stream ISO contents";
     }
 }

Emby.Server.Implementations/IO/IsoManager.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -8,12 +9,12 @@ using MediaBrowser.Model.IO;
 namespace Emby.Server.Implementations.IO
 {
     /// <summary>
-    /// Class IsoManager
+    /// Class IsoManager.
     /// </summary>
     public class IsoManager : IIsoManager
     {
         /// <summary>
-        /// The _mounters
+        /// The _mounters.
         /// </summary>
         private readonly List<IIsoMounter> _mounters = new List<IIsoMounter>();
 
@@ -22,9 +23,7 @@ namespace Emby.Server.Implementations.IO
         /// </summary>
         /// <param name="isoPath">The iso path.</param>
         /// <param name="cancellationToken">The cancellation token.</param>
-        /// <returns>IsoMount.</returns>
-        /// <exception cref="ArgumentNullException">isoPath</exception>
-        /// <exception cref="ArgumentException"></exception>
+        /// <returns><see creaf="IsoMount" />.</returns>
         public Task<IIsoMount> Mount(string isoPath, CancellationToken cancellationToken)
         {
             if (string.IsNullOrEmpty(isoPath))
@@ -36,7 +35,11 @@ namespace Emby.Server.Implementations.IO
 
             if (mounter == null)
             {
-                throw new ArgumentException(string.Format("No mounters are able to mount {0}", isoPath));
+                throw new ArgumentException(
+                    string.Format(
+                        CultureInfo.InvariantCulture,
+                        "No mounters are able to mount {0}",
+                        isoPath));
             }
 
             return mounter.Mount(isoPath, cancellationToken);
@@ -60,16 +63,5 @@ namespace Emby.Server.Implementations.IO
         {
             _mounters.AddRange(mounters);
         }
-
-        /// <summary>
-        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
-        /// </summary>
-        public void Dispose()
-        {
-            foreach (var mounter in _mounters)
-            {
-                mounter.Dispose();
-            }
-        }
     }
 }

Emby.Server.Implementations/SocketSharp/WebSocketSharpListener.cs

@@ -117,7 +117,7 @@ namespace Emby.Server.Implementations.SocketSharp
         /// <summary>
         /// Releases the unmanaged resources and disposes of the managed resources used.
         /// </summary>
-        /// <param name="disposing">Whether or not the managed resources should be disposed</param>
+        /// <param name="disposing">Whether or not the managed resources should be disposed.</param>
         protected virtual void Dispose(bool disposing)
         {
             if (_disposed)

MediaBrowser.Model/IO/IIsoManager.cs

@@ -6,7 +6,7 @@ using System.Threading.Tasks;
 
 namespace MediaBrowser.Model.IO
 {
-    public interface IIsoManager : IDisposable
+    public interface IIsoManager
     {
         /// <summary>
         /// Mounts the specified iso path.

MediaBrowser.Model/IO/IIsoMounter.cs

@@ -5,7 +5,7 @@ using System.Threading.Tasks;
 
 namespace MediaBrowser.Model.IO
 {
-    public interface IIsoMounter : IDisposable
+    public interface IIsoMounter
     {
         /// <summary>
         /// Mounts the specified iso path.

MediaBrowser.Model/Plugins/BasePluginConfiguration.cs

@@ -1,7 +1,7 @@
 namespace MediaBrowser.Model.Plugins
 {
     /// <summary>
-    /// Class BasePluginConfiguration
+    /// Class BasePluginConfiguration.
     /// </summary>
     public class BasePluginConfiguration
     {