public async Task <Stream> GetListingsStream(TunerHostInfo info, CancellationToken cancellationToken)
{
if (info == null)
{
throw new ArgumentNullException(nameof(info));
}
if (!info.Url.StartsWith("http", StringComparison.OrdinalIgnoreCase))
{
return(AsyncFile.OpenRead(info.Url));
}
using var requestMessage = new HttpRequestMessage(HttpMethod.Get, info.Url);
if (!string.IsNullOrEmpty(info.UserAgent))
{
requestMessage.Headers.UserAgent.TryParseAdd(info.UserAgent);
}
// Set HttpCompletionOption.ResponseHeadersRead to prevent timeouts on larger files
var response = await _httpClientFactory.CreateClient(NamedClient.Default)
.SendAsync(requestMessage, HttpCompletionOption.ResponseHeadersRead, cancellationToken)
.ConfigureAwait(false);
response.EnsureSuccessStatusCode();
return(await response.Content.ReadAsStreamAsync(cancellationToken));
}
public async Task CancellationToken_ExceptionThrown()
{
var contents = Enumerable.Repeat("This is a test line.", 300000).ToList();
var path = Path.Combine(moveTestFolder, nameof(CancellationToken_ExceptionThrown));
Directory.CreateDirectory(moveTestFolder);
File.WriteAllLines(path, contents);
var movePath = Path.Combine(moveTestFolder, $"{nameof(CancellationToken_ExceptionThrown)}_Moved");
File.Delete(movePath);
var tokenSource = new CancellationTokenSource();
Assert.ThrowsAsync <TaskCanceledException>(async() =>
{
var task = AsyncFile.MoveAsync(path, movePath, tokenSource.Token);
tokenSource.Cancel();
await task;
});
var result = File.ReadAllLines(movePath);
Assert.IsTrue(contents.Count > result.Length);
Assert.IsTrue(File.Exists(path));
}
/// <inheritdoc />
public async Task <ForgotPasswordResult> StartForgotPasswordProcess(User user, bool isInNetwork)
{
byte[] bytes = new byte[4];
RandomNumberGenerator.Fill(bytes);
string pin = BitConverter.ToString(bytes);
DateTime expireTime = DateTime.UtcNow.AddMinutes(30);
string filePath = _passwordResetFileBase + user.Id + ".json";
SerializablePasswordReset spr = new SerializablePasswordReset
{
ExpirationDate = expireTime,
Pin = pin,
PinFile = filePath,
UserName = user.Username
};
await using (FileStream fileStream = AsyncFile.OpenWrite(filePath))
{
await JsonSerializer.SerializeAsync(fileStream, spr).ConfigureAwait(false);
}
user.EasyPassword = pin;
return(new ForgotPasswordResult
{
Action = ForgotPasswordAction.PinCode,
PinExpirationDate = expireTime,
PinFile = filePath
});
}
public void CancellationTokenOverwrite_ExceptionThrown()
{
var contents = Enumerable.Repeat("This is a test line.", 300000).ToList();
var path = Path.Combine(copyTestFolder, nameof(CancellationTokenOverwrite_ExceptionThrown));
Directory.CreateDirectory(copyTestFolder);
File.WriteAllLines(path, contents);
var copyPath = Path.Combine(copyTestFolder, $"{nameof(CancellationTokenOverwrite_ExceptionThrown)}_Copy");
if (!File.Exists(copyPath))
{
File.Create(copyPath).Dispose();
}
var tokenSource = new CancellationTokenSource();
Assert.ThrowsAsync <TaskCanceledException>(async() =>
{
var task = AsyncFile.CopyAsync(path, copyPath, true, tokenSource.Token);
tokenSource.Cancel();
await task;
});
var result = File.ReadAllLines(copyPath);
Assert.IsTrue(contents.Count > result.Length);
}
protected override Task DispatchAsyncCore(SetupContext context, CancellationToken cancellationToken)
{
FileInfo file = context.ResolveFile(this.File);
file.Directory.Create();
return(AsyncFile.WriteAllBytesAsync(file.FullName, this.Data.ToArray()));
}
/// <summary>
/// Sets the ass font.
/// </summary>
/// <param name="file">The file.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <c>System.Threading.CancellationToken.None</c>.</param>
/// <returns>Task.</returns>
private async Task SetAssFont(string file, CancellationToken cancellationToken = default)
{
_logger.LogInformation("Setting ass font within {File}", file);
string text;
Encoding encoding;
using (var fileStream = AsyncFile.OpenRead(file))
using (var reader = new StreamReader(fileStream, true))
{
encoding = reader.CurrentEncoding;
text = await reader.ReadToEndAsync().ConfigureAwait(false);
}
var newText = text.Replace(",Arial,", ",Arial Unicode MS,", StringComparison.Ordinal);
if (!string.Equals(text, newText, StringComparison.Ordinal))
{
var fileStream = new FileStream(file, FileMode.Create, FileAccess.Write, FileShare.None, IODefaults.FileStreamBufferSize, FileOptions.Asynchronous);
var writer = new StreamWriter(fileStream, encoding);
await using (fileStream.ConfigureAwait(false))
await using (writer.ConfigureAwait(false))
{
await writer.WriteAsync(newText.AsMemory(), cancellationToken).ConfigureAwait(false);
}
}
}
private static async Task <string> UnpackExecutableAsync()
{
string targetPath = Path.Combine(Path.GetTempPath(), "STEP_EXEs");
Directory.CreateDirectory(targetPath);
targetPath = Path.Combine(targetPath, "7z.dll");
var arch = Environment.Is64BitProcess ? "7z-x64.dll" : "7z-x86.dll";
using (var executableStream = ResourceUtility.OpenEmbeddedResourceFile(arch))
using (var targetStream = AsyncFile.CreateSequential(targetPath))
{
await executableStream.CopyToAsync(targetStream).ConfigureAwait(false);
}
targetPath = Path.ChangeExtension(targetPath, "exe");
arch = Environment.Is64BitProcess ? "7z-x64.exe" : "7z-x86.exe";
using (var executableStream = ResourceUtility.OpenEmbeddedResourceFile(arch))
using (var targetStream = AsyncFile.CreateSequential(targetPath))
{
await executableStream.CopyToAsync(targetStream).ConfigureAwait(false);
}
return(targetPath);
}
public async Task LoadPresetsForPlugin(Plugin plugin)
{
var presetsStorageFile = GetPresetsStorageFile(plugin);
if (!File.Exists(presetsStorageFile))
{
presetsStorageFile = FindPresetStorageFileById(plugin.PluginId);
if (presetsStorageFile == null)
{
return;
}
}
if (File.Exists(presetsStorageFile))
{
var presets = GetLoadSerializer()
.Deserialize <EditableCollection <Preset> >(await AsyncFile.ReadAllBytesAsync(presetsStorageFile));
foreach (var preset in presets)
{
preset.Plugin = plugin;
}
plugin.Presets = presets;
plugin.OnAfterCerasDeserialize();
}
}
internal async Task <SeasonRootObject> GetSeasonRootObject(string imdbId, int seasonId, CancellationToken cancellationToken)
{
var path = await EnsureSeasonInfo(imdbId, seasonId, cancellationToken).ConfigureAwait(false);
await using var stream = AsyncFile.OpenRead(path);
return(await JsonSerializer.DeserializeAsync <SeasonRootObject>(stream, _jsonOptions, cancellationToken).ConfigureAwait(false));
}
public void NullContent_ExceptionThrown()
{
var path = Path.Combine(writeAllTextTestFolder, nameof(NullContent_ExceptionThrown));
Directory.CreateDirectory(writeAllTextTestFolder);
Assert.ThrowsAsync <ArgumentNullException>(async() => await AsyncFile.WriteAllTextAsync(path, null));
}
private async Task<Stream> GetAttachmentStream(
MediaSourceInfo mediaSource,
MediaAttachment mediaAttachment,
CancellationToken cancellationToken)
{
var attachmentPath = await GetReadableFile(mediaSource.Path, mediaSource.Path, mediaSource, mediaAttachment, cancellationToken).ConfigureAwait(false);
return AsyncFile.OpenRead(attachmentPath);
}
public void AppendAllTextAsync_NullEncoding_ExceptionThrown()
{
var contents = "This is a test line.";
var path = Path.Combine(appendAllTextTestFolder, "AppendAllLinesAsync_Default_LinesAppended");
Directory.CreateDirectory(appendAllTextTestFolder);
Assert.ThrowsAsync <ArgumentNullException>(async() => await AsyncFile.AppendAllTextAsync(path, contents, null));
}
/// <inheritdoc />
public async Task ProcessImage(ImageProcessingOptions options, Stream toStream)
{
var file = await ProcessImage(options).ConfigureAwait(false);
using (var fileStream = AsyncFile.OpenRead(file.Path))
{
await fileStream.CopyToAsync(toStream).ConfigureAwait(false);
}
}
public async Task Test(string fileName)
{
var path = Path.Join("Test Data", fileName);
await using (var stream = AsyncFile.OpenRead(path))
{
var res = await JsonSerializer.DeserializeAsync<InternalMediaInfoResult>(stream, JsonDefaults.Options).ConfigureAwait(false);
Assert.NotNull(res);
}
}
public void NullEncoding_ExceptionThrown()
{
var contents = Enumerable.Repeat("This is a test line.", 150).ToList();
var path = Path.Combine(appendAllLinesTestFolder, nameof(NullEncoding_ExceptionThrown));
Directory.CreateDirectory(appendAllLinesTestFolder);
Assert.ThrowsAsync <ArgumentNullException>(async() => await AsyncFile.AppendAllLinesAsync(path, contents, null));
}
public static async Task <TryResult> TryDeleteAsync(string path)
{
Exception exception = null;
try { await AsyncFile.DeleteAsync(path); }
catch (Exception ex) { exception = ex; }
return(new TryResult(!File.Exists(path), exception));
}
public void WriteAllTextAsync_NullEncoding_ExceptionThrown()
{
const string content = "This is a test line.";
var path = Path.Combine(writeAllTextTestFolder, nameof(NullContent_ExceptionThrown));
Directory.CreateDirectory(writeAllTextTestFolder);
Assert.ThrowsAsync <ArgumentNullException>(async() => await AsyncFile.WriteAllTextAsync(path, content, null));
}
public static async Task <bool> TryAndRetryDeleteAsync(string path, int times = 10, int delay = 50, bool throwEx = true, Action middleAction = null, Task middleTask = null)
{
if (!File.Exists(path))
{
return(true);
}
await Threading.MultipleAttempts(AsyncFile.DeleteAsync(path), times, delay, throwEx, middleAction, middleTask);
return(!File.Exists(path));
}
public static async Task CopyAsync(string sourceFileName, string destFileName, bool overwrite, CancellationToken cancellationToken)
{
string dir = Path.GetDirectoryName(destFileName);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
await AsyncFile.CopyAsync(sourceFileName, destFileName, overwrite, cancellationToken);
}
public static async Task CopyAsync(string sourceFileName, string destFileName)
{
string dir = Path.GetDirectoryName(destFileName);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
await AsyncFile.CopyAsync(sourceFileName, destFileName);
}
public void NullEncoding_ExceptionThrown()
{
var contents = Enumerable.Repeat("This is a test line.", 30000).ToList();
var path = Path.Combine(readAllLinesTestFolder, nameof(NullEncoding_ExceptionThrown));
Directory.CreateDirectory(FileTestFolder);
File.WriteAllLines(path, contents);
Assert.ThrowsAsync <ArgumentNullException>(async() => await AsyncFile.ReadAllLinesAsync(path, null).ConfigureAwait(false));
}
public void NullEncoding_ExceptionThrown()
{
var contents = string.Join(Environment.NewLine, Enumerable.Repeat("This is a test line.", 150));
var path = Path.Combine(readAllTextTestFolder, nameof(NullEncoding_ExceptionThrown));
Directory.CreateDirectory(readAllTextTestFolder);
File.WriteAllText(path, contents);
Assert.ThrowsAsync <ArgumentNullException>(async() => await AsyncFile.ReadAllTextAsync(path, null).ConfigureAwait(false));
}
public static async Task DeleteAsync(string path)
{
foreach (string dir in Directory.EnumerateDirectories(path))
{
await DeleteAsync(dir);
}
foreach (string file in Directory.EnumerateFiles(path))
{
await AsyncFile.DeleteAsync(file);
}
}
public async Task <List <ChannelInfo> > GetChannels(bool enableCache, CancellationToken cancellationToken)
{
var list = new List <ChannelInfo>();
var hosts = GetTunerHosts();
foreach (var host in hosts)
{
var channelCacheFile = Path.Combine(Config.ApplicationPaths.CachePath, host.Id + "_channels");
try
{
var channels = await GetChannels(host, enableCache, cancellationToken).ConfigureAwait(false);
var newChannels = channels.Where(i => !list.Any(l => string.Equals(i.Id, l.Id, StringComparison.OrdinalIgnoreCase))).ToList();
list.AddRange(newChannels);
if (!enableCache)
{
try
{
Directory.CreateDirectory(Path.GetDirectoryName(channelCacheFile));
await using var writeStream = AsyncFile.OpenWrite(channelCacheFile);
await JsonSerializer.SerializeAsync(writeStream, channels, cancellationToken : cancellationToken).ConfigureAwait(false);
}
catch (IOException)
{
}
}
}
catch (Exception ex)
{
Logger.LogError(ex, "Error getting channel list");
if (enableCache)
{
try
{
await using var readStream = AsyncFile.OpenRead(channelCacheFile);
var channels = await JsonSerializer.DeserializeAsync <List <ChannelInfo> >(readStream, cancellationToken : cancellationToken)
.ConfigureAwait(false);
list.AddRange(channels);
}
catch (IOException)
{
}
}
}
}
return(list);
}
public Task SaveImage(BaseItem item, string source, string mimeType, ImageType type, int?imageIndex, bool?saveLocallyWithMedia, CancellationToken cancellationToken)
{
if (string.IsNullOrWhiteSpace(source))
{
throw new ArgumentNullException(nameof(source));
}
var fileStream = AsyncFile.OpenRead(source);
return(new ImageSaver(_configurationManager, _libraryMonitor, _fileSystem, _logger).SaveImage(item, fileStream, mimeType, type, imageIndex, saveLocallyWithMedia, cancellationToken));
}
public async Task ReadAllLinesWithEncoding(Encoding encoding)
{
var contents = Enumerable.Repeat("This is a test line.", 150).ToList();
var path = Path.Combine(readAllLinesTestFolder, nameof(ReadAllLinesWithEncoding));
Directory.CreateDirectory(readAllLinesTestFolder);
File.WriteAllLines(path, contents, encoding);
var result = await AsyncFile.ReadAllLinesAsync(path, encoding).ConfigureAwait(false);
CollectionAssert.AreEqual(contents, result);
}
public async Task ReadAllTextWithEncoding(Encoding encoding)
{
var contents = string.Join(Environment.NewLine, Enumerable.Repeat("This is a test line.", 150));
var path = Path.Combine(readAllTextTestFolder, nameof(ReadAllTextWithEncoding));
Directory.CreateDirectory(readAllTextTestFolder);
File.WriteAllText(path, contents, encoding);
var result = await AsyncFile.ReadAllTextAsync(path, encoding).ConfigureAwait(false);
Assert.AreEqual(contents, result);
}
public async Task Default_TextAppended()
{
var contents = string.Join(Environment.NewLine, Enumerable.Repeat("This is a test line.", 150));
var path = Path.Combine(writeAllTextTestFolder, nameof(Default_TextAppended));
Directory.CreateDirectory(writeAllTextTestFolder);
await AsyncFile.WriteAllTextAsync(path, contents);
var result = File.ReadAllText(path);
Assert.AreEqual(contents, result);
}
public async Task Default_FileDeleted()
{
var contents = Enumerable.Repeat("This is a test line.", 150).ToList();
var path = Path.Combine(deleteTestFolder, nameof(Default_FileDeleted));
Directory.CreateDirectory(deleteTestFolder);
File.WriteAllLines(path, contents);
await AsyncFile.DeleteAsync(path);
Assert.IsFalse(File.Exists(path));
}
public async Task Default_LinesAppended()
{
var contents = Enumerable.Repeat("This is a test line.", 150).ToList();
var path = Path.Combine(writeAllLinesTestFolder, nameof(Default_LinesAppended));
Directory.CreateDirectory(writeAllLinesTestFolder);
await AsyncFile.WriteAllLinesAsync(path, contents);
var result = File.ReadAllLines(path);
CollectionAssert.AreEqual(contents, result);
}