public PoolingSettings(string poolDisplayName = default, bool isDisabled = default, int?poolSize = default, TimeoutDuration preferredSlidingTtl = default, bool isReadOnly = default)
: base(isReadOnly : isReadOnly)
{
_poolDisplayName = poolDisplayName;
_isDisabled = isDisabled;
_poolSize = poolSize;
_preferredSlidingTtl = preferredSlidingTtl;
}
public RetrySettings(bool isDisabled = default, int maxCount = default, TimeoutDuration interval = default, bool isReadOnly = default)
: base(isReadOnly : isReadOnly)
{
//
_isDisabled = isDisabled;
_maxCount = maxCount;
_interval = interval;
}
public Pool(
Func <IContext, Task <T> > itemFactory,
bool ownsItem,
TimeoutDuration itemPreferredSlidingTtl,
int maxSize,
string displayName = default,
ArgumentPlaceholder <ILogger> logger = default)
{
//
itemFactory.EnsureNotNull(nameof(itemFactory));
itemPreferredSlidingTtl.EnsureNotNull(nameof(itemPreferredSlidingTtl));
maxSize.Arg(nameof(maxSize)).EnsureNotLessThan(operand: 1);
displayName.Arg(nameof(displayName)).EnsureNotEmpty().EnsureHasMaxLength(maxLength: Pool.DisplayNameMaxLength);
//
_itemFactory = itemFactory;
_ownsFactoriedItem = ownsItem;
ItemPreferredSlidingTtl = itemPreferredSlidingTtl;
MaxSize = maxSize;
P_MaxSizeMinusOne = maxSize - 1;
DisplayName = displayName;
_poolItems = ImmutableStack <ImmutableStackEntry <Leasable <T> > > .Empty;
_logger = logger.Substitute(value: default);
public LockSmallTimeoutOption(TimeoutDuration timeout)
{
timeout.EnsureNotNull(nameof(timeout)).EnsureNotInfinite().Value.Milliseconds.ArgProp($"{nameof(timeout)}.{nameof(timeout.Milliseconds)}").EnsureNotGreaterThan(operand: MaxTimeout.Milliseconds);
//
_timeout = timeout;
}
static LockSmallTimeoutOption()
{
MaxTimeout = TimeoutDuration.FromMilliseconds(milliseconds: 2819);
Fallback = new LockSmallTimeoutOption(timeout: TimeoutDuration.FromMilliseconds(milliseconds: 937));
RuntimeOptions.Option <LockSmallTimeoutOption> .SetFallback(option : Fallback);
}
// TODO: Add component info into log
//
/// <summary>
/// Создает ZIP-архив файла <paramref name="sourceFile"/>, сохраняет его по пути <paramref name="archiveFile"/>.
/// <para>При <paramref name="deleteSourceFileOnSuccess"/> = <see langword="true"/>, исходный файл удаляется.</para>
/// </summary>
/// <param name="sourceFile">
/// Файл-источник архивирования.
/// <para>Не может быть <see langword="null"/>. Файл должен существовать.</para>
/// </param>
/// <param name="archiveFile">
/// Файл-приёмник архивирования.
/// <para>Не может быть <see langword="null"/>.</para>
/// </param>
/// <param name="overwrite">
/// Флаг перезаписи файла-приемника <paramref name="archiveFile"/>, если такой существует.
/// </param>
/// <param name="deleteSourceFileOnSuccess">
/// Флаг удаления файла-источника при успешном архивировании (исключения при удалении не выбрасываются).
/// </param>
/// <param name="overrideSourceFileName">
/// Переопределяет имя исходного файла в ZIP-архиве.
/// <para>Если не указано, то имя соответствует имени исходного файла <paramref name="sourceFile"/>.</para>
/// </param>
/// <param name="ctx">
/// Контекст выполнения операции.
/// </param>
public static async Task ZipArchiveFileAsync(FileInfo sourceFile, FileInfo archiveFile, bool deleteSourceFileOnSuccess, string overrideSourceFileName = default, bool overwrite = default, IContext ctx = default)
{
sourceFile.EnsureNotNull(nameof(sourceFile));
archiveFile.EnsureNotNull(nameof(archiveFile));
overrideSourceFileName.Arg(nameof(overrideSourceFileName)).EnsureNotEmpty();
//
if (!sourceFile.Exists)
{
throw new FileNotFoundException(FormatXResource(typeof(FileNotFoundException), null, sourceFile.FullName));
}
try {
var ct = ctx.Ct();
FileStream sourceFileStream = default;
try {
var retryOpen = true;
for (; ;)
{
try {
sourceFileStream = new FileStream(path: sourceFile.FullName, mode: FileMode.Open, access: FileAccess.Read, share: FileShare.Read);
break;
}
catch (IOException ex) {
if (retryOpen)
{
retryOpen = false;
await TaskUtilities.Delay(duration : TimeoutDuration.FromMilliseconds(937), cancellationToken : ct, cancellationBreak : true).ConfigureAwait(false);
continue;
}
else
{
throw new EonException(message: $"Ошибка при архивировании: файл-источник невозможно открыть для чтения.{Environment.NewLine}\tФайл:{sourceFile.FullName.FmtStr().GNLI2()}", innerException: ex);
}
}
}
archiveFile.Directory.Refresh();
if (!archiveFile.Directory.Exists)
{
archiveFile.Directory.Create();
}
var archiveFileStream = default(FileStream);
var zipArchive = default(ZipArchive);
try {
try {
archiveFileStream = new FileStream(path: archiveFile.FullName, mode: overwrite ? FileMode.Create : FileMode.CreateNew, access: FileAccess.ReadWrite, share: FileShare.Read);
}
catch (Exception ex) {
throw
new EonException(message: $"Ошибка при архивировании: невозможно открыть поток для записи.{Environment.NewLine}\tФайл:{archiveFile.FullName.FmtStr().GNLI2()}", innerException: ex);
}
zipArchive = new ZipArchive(stream: archiveFileStream, mode: ZipArchiveMode.Create, leaveOpen: false, entryNameEncoding: Encoding.UTF8);
var zipEntry = zipArchive.CreateEntry(entryName: overrideSourceFileName ?? sourceFile.Name, compressionLevel: CompressionLevel.Optimal);
using (var zipEntryStream = zipEntry.Open()) {
await sourceFileStream.CopyToAsync(destination : zipEntryStream, cancellationToken : ct).ConfigureAwait(false);
await zipEntryStream.FlushAsync(cancellationToken : ct).ConfigureAwait(false);
}
}
catch (Exception ex) {
throw
new EonException(
message: $"Ошибка при архивировании.{Environment.NewLine}\tФайл-источник:{sourceFile.FullName.FmtStr().GNLI2()}{Environment.NewLine}\tФайл-приемник:{archiveFile.FullName.FmtStr().GNLI2()}",
innerException: ex);
}
finally {
zipArchive?.Dispose();
archiveFileStream?.Dispose();
}
}
finally {
sourceFileStream?.Dispose();
}
if (deleteSourceFileOnSuccess)
{
var retryDelete = true;
for (; ;)
{
try {
sourceFile.Delete();
break;
}
catch (IOException) {
if (retryDelete)
{
retryDelete = false;
await TaskUtilities.Delay(duration : TimeoutDuration.FromMilliseconds(937), cancellationToken : ct, cancellationBreak : true).ConfigureAwait(false);
continue;
}
else
{
break;
}
}
}
}
}
catch (Exception exception) {
throw
new EonException(
message: $"Ошибка при архивировании.{Environment.NewLine}\tФайл-источник:{sourceFile.FullName.FmtStr().GNLI2()}{Environment.NewLine}\tФайл-приемник:{archiveFile.FullName.FmtStr().GNLI2()}",
innerException: exception);
}
}
public LockTimeoutOption(TimeoutDuration timeout)
{
timeout.EnsureNotNull(nameof(timeout)).EnsureNotInfinite();
//
_timeout = timeout;
}
public AsyncOperationTimeoutOption(TimeoutDuration timeout)
{
timeout.EnsureNotNull(nameof(timeout)).EnsureNotInfinite();
//
Timeout = timeout;
}
static LockTimeoutOption()
{
Fallback = new LockTimeoutOption(timeout: TimeoutDuration.FromMilliseconds(milliseconds: 30011));
RuntimeOptions.Option <LockTimeoutOption> .SetFallback(option : Fallback);
}
static AsyncOperationTimeoutOption()
{
Fallback = new AsyncOperationTimeoutOption(timeout: TimeoutDuration.FromMilliseconds(milliseconds: 20011));
RuntimeOptions.Option <AsyncOperationTimeoutOption> .SetFallback(option : Fallback);
}
public Leasable(Func <IContext, Task <T> > acquire, bool ownsAcquired, TimeoutDuration preferredSlidingTtl, ArgumentPlaceholder <ILogger> logger = default)
: this(acquire : P_GetAcquireDelegate(acquire : acquire, ownsAcquired : ownsAcquired), release : P_DefaultRelease, preferredSlidingTtl : preferredSlidingTtl, logger : logger)
{
}
public Leasable(Func <IContext, Task <IVh <T> > > acquire, TimeoutDuration preferredSlidingTtl, ArgumentPlaceholder <ILogger> logger = default)
: this(acquire : acquire, release : P_DefaultRelease, preferredSlidingTtl : preferredSlidingTtl, logger : logger)
{
}
public Leasable(Func <IContext, Task <IVh <T> > > acquire, Func <IVh <T>, Task> release, TimeoutDuration preferredSlidingTtl, ArgumentPlaceholder <ILogger> logger = default)
: base(preferredSlidingTtl : preferredSlidingTtl, logger : logger)
{
//
acquire.EnsureNotNull(nameof(acquire));
release.EnsureNotNull(nameof(release));
//
_acquire = acquire;
_release = release;
}
public Leasable(Func <IVh <T> > acquire, Action <IVh <T> > release, TimeoutDuration preferredSlidingTtl, ArgumentPlaceholder <ILogger> logger = default)
: this(acquire : P_GetAcquireDelegate(acquire : acquire), release : P_GetReleaseDelegate(release : release), preferredSlidingTtl : preferredSlidingTtl, logger : logger)
{
}
