open-source-mirrors
/
jellyfin
mirror of https://github.com/jellyfin/jellyfin
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add analysers to Emby.IsoMounting and enable TreatWarningsAsErrors

Browse Source
pull/1636/head
Bond_009 5 years ago
parent 7a27dd8a1b
commit dc662beefe
10 changed files with 215 additions and 409 deletions
Show Stats Download Patch File Download Diff File

3
Emby.IsoMounting/IsoMounter/Configuration/PluginConfiguration.cs
Unescape View File

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

12
Emby.IsoMounting/IsoMounter/IsoMounter.csproj
Unescape View File

@ -13,6 +13,18 @@
<TargetFramework>netstandard2.0</TargetFramework> <TargetFramework>netstandard2.0</TargetFramework>
<GenerateAssemblyInfo>false</GenerateAssemblyInfo> <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
<GenerateDocumentationFile>true</GenerateDocumentationFile> <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> </PropertyGroup>
</Project> </Project>

477
Emby.IsoMounting/IsoMounter/LinuxIsoManager.cs
Unescape View File

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

73
Emby.IsoMounting/IsoMounter/LinuxMount.cs
Unescape View File

@ -3,81 +3,56 @@ using MediaBrowser.Model.IO;
namespace IsoMounter namespace IsoMounter
{ {
/// <summary>
/// Class LinuxMount.
/// </summary>
internal class LinuxMount : IIsoMount internal class LinuxMount : IIsoMount
{ {
private readonly LinuxIsoManager _linuxIsoManager;
#region Private Fields private bool _disposed = false;
private readonly LinuxIsoManager linuxIsoManager;
#endregion
#region Constructor(s)
/// <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) internal LinuxMount(LinuxIsoManager isoManager, string isoPath, string mountFolder)
{ {
_linuxIsoManager = isoManager;
linuxIsoManager = isoManager;
IsoPath = isoPath; IsoPath = isoPath;
MountedPath = mountFolder; MountedPath = mountFolder;
} }
#endregion /// <inheritdoc />
public string IsoPath { get; }
#region Interface Implementation for IDisposable
// Flag: Has Dispose already been called? /// <inheritdoc />
private bool disposed = false; public string MountedPath { get; }
/// <inheritdoc />
public void Dispose() public void Dispose()
{ {
// Dispose of unmanaged resources.
Dispose(true); Dispose(true);
// Suppress finalization.
GC.SuppressFinalize(this); 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) protected virtual void Dispose(bool disposing)
{ {
if (_disposed)
if (disposed)
{ {
return; return;
} }
if (disposing) _linuxIsoManager.OnUnmount(this);
{
//
// Free managed objects here.
//
linuxIsoManager.OnUnmount(this);
}
//
// Free any unmanaged objects here.
//
disposed = true;
_disposed = true;
} }
#endregion
#region Interface Implementation for IIsoMount
public string IsoPath { get; private set; }
public string MountedPath { get; private set; }
#endregion
} }
} }

25
Emby.IsoMounting/IsoMounter/Plugin.cs
Unescape View File

@ -6,25 +6,28 @@ using MediaBrowser.Model.Serialization;
namespace IsoMounter namespace IsoMounter
{ {
/// <summary>
/// The LinuxMount plugin class.
/// </summary>
public class Plugin : BasePlugin<PluginConfiguration> 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"); /// <inheritdoc />
public override Guid Id => _id; public override Guid Id { get; } = new Guid("4682DD4C-A675-4F1B-8E7C-79ADF137A8F8");
/// <summary> /// <inheritdoc />
/// Gets the name of the plugin
/// </summary>
/// <value>The name.</value>
public override string Name => "Iso Mounter"; public override string Name => "Iso Mounter";
/// <summary> /// <inheritdoc />
/// Gets the description.
/// </summary>
/// <value>The description.</value>
public override string Description => "Mount and stream ISO contents"; public override string Description => "Mount and stream ISO contents";
} }
} }

26
Emby.Server.Implementations/IO/IsoManager.cs
Unescape View File

@ -1,5 +1,6 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Globalization;
using System.Linq; using System.Linq;
using System.Threading; using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
@ -8,12 +9,12 @@ using MediaBrowser.Model.IO;
namespace Emby.Server.Implementations.IO namespace Emby.Server.Implementations.IO
{ {
/// <summary> /// <summary>
/// Class IsoManager /// Class IsoManager.
/// </summary> /// </summary>
public class IsoManager : IIsoManager public class IsoManager : IIsoManager
{ {
/// <summary> /// <summary>
/// The _mounters /// The _mounters.
/// </summary> /// </summary>
private readonly List<IIsoMounter> _mounters = new List<IIsoMounter>(); private readonly List<IIsoMounter> _mounters = new List<IIsoMounter>();
@ -22,9 +23,7 @@ namespace Emby.Server.Implementations.IO
/// </summary> /// </summary>
/// <param name="isoPath">The iso path.</param> /// <param name="isoPath">The iso path.</param>
/// <param name="cancellationToken">The cancellation token.</param> /// <param name="cancellationToken">The cancellation token.</param>
/// <returns>IsoMount.</returns> /// <returns><see creaf="IsoMount" />.</returns>
/// <exception cref="ArgumentNullException">isoPath</exception>
/// <exception cref="ArgumentException"></exception>
public Task<IIsoMount> Mount(string isoPath, CancellationToken cancellationToken) public Task<IIsoMount> Mount(string isoPath, CancellationToken cancellationToken)
{ {
if (string.IsNullOrEmpty(isoPath)) if (string.IsNullOrEmpty(isoPath))
@ -36,7 +35,11 @@ namespace Emby.Server.Implementations.IO
if (mounter == null) 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); return mounter.Mount(isoPath, cancellationToken);
@ -60,16 +63,5 @@ namespace Emby.Server.Implementations.IO
{ {
_mounters.AddRange(mounters); _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();
}
}
} }
} }

2
Emby.Server.Implementations/SocketSharp/WebSocketSharpListener.cs
Unescape View File

@ -117,7 +117,7 @@ namespace Emby.Server.Implementations.SocketSharp
/// <summary> /// <summary>
/// Releases the unmanaged resources and disposes of the managed resources used. /// Releases the unmanaged resources and disposes of the managed resources used.
/// </summary> /// </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) protected virtual void Dispose(bool disposing)
{ {
if (_disposed) if (_disposed)

2
MediaBrowser.Model/IO/IIsoManager.cs
Unescape View File

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

2
MediaBrowser.Model/IO/IIsoMounter.cs
Unescape View File

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

2
MediaBrowser.Model/Plugins/BasePluginConfiguration.cs
Unescape View File

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

Write Preview
Loading…
Cancel
Save