From 9bb7b5eff8437aed279c63d360ca8b39e833671d Mon Sep 17 00:00:00 2001 From: Pavel Gross Date: Mon, 2 Dec 2024 19:33:45 +0300 Subject: [PATCH] [#28] Clients: Make immutable parameters Signed-off-by: Pavel Gross --- src/FrostFS.SDK.Client/FrostFSClient.cs | 193 ++--- .../Interfaces/IFrostFSClient.cs | 46 +- .../Models/Chain/ChainTarget.cs | 17 +- .../Models/Object/FrostFsHeaderResult.cs | 8 + .../Models/Object/FrostFsSplit.cs | 1 - .../Models/Object/FrostFsSplitInfo.cs | 26 + .../Parameters/CallContext.cs | 38 +- .../Parameters/Credentials.cs | 10 - src/FrostFS.SDK.Client/Parameters/IContext.cs | 11 - .../Parameters/ISessionToken.cs | 2 +- .../Parameters/PrmApeChainAdd.cs | 43 ++ .../Parameters/PrmApeChainList.cs | 36 +- .../Parameters/PrmApeChainRemove.cs | 40 +- .../Parameters/PrmApeRemoveAdd.cs | 8 - .../Parameters/PrmBalance.cs | 5 - src/FrostFS.SDK.Client/Parameters/PrmBase.cs | 14 - .../Parameters/PrmContainerCreate.cs | 52 +- .../Parameters/PrmContainerDelete.cs | 46 +- .../Parameters/PrmContainerGet.cs | 38 +- .../Parameters/PrmContainerGetAll.cs | 38 +- .../Parameters/PrmNetmapSnapshot.cs | 5 - .../Parameters/PrmNetworkSettings.cs | 5 - .../Parameters/PrmNodeInfo.cs | 5 - .../Parameters/PrmObjectDelete.cs | 48 +- .../Parameters/PrmObjectGet.cs | 49 +- .../Parameters/PrmObjectHeadGet.cs | 53 +- .../Parameters/PrmObjectPatch.cs | 61 +- .../Parameters/PrmObjectPut.cs | 62 +- .../Parameters/PrmObjectSearch.cs | 52 +- .../Parameters/PrmRangeGet.cs | 43 +- .../Parameters/PrmRangeHashGet.cs | 44 +- .../Parameters/PrmSessionCreate.cs | 38 +- .../Parameters/PrmSingleObjectPut.cs | 39 +- src/FrostFS.SDK.Client/Parameters/PrmWait.cs | 36 +- .../Parameters/PutObjectContext.cs | 10 + src/FrostFS.SDK.Client/Pool/ClientWrapper.cs | 12 +- src/FrostFS.SDK.Client/Pool/Pool.cs | 103 ++- .../Services/AccountingServiceProvider.cs | 8 +- .../Services/ApeManagerServiceProvider.cs | 18 +- .../Services/ContainerServiceProvider.cs | 34 +- .../Services/NetmapServiceProvider.cs | 20 +- .../Services/ObjectServiceProvider.cs | 125 ++- .../Services/SessionServiceProvider.cs | 8 +- .../Services/Shared/SessionProvider.cs | 2 +- src/FrostFS.SDK.Client/Tools/ObjectTools.cs | 10 - .../Tools/RequestConstructor.cs | 18 +- .../FrostFS.SDK.Cryptography.csproj | 2 +- src/FrostFS.SDK.Tests/GlobalSuppressions.cs | 6 - .../Multithread/MultiThreadTestsBase.cs | 42 ++ .../MultithreadPoolSmokeTests.cs} | 223 +++--- .../MultithreadSmokeClientTests.cs} | 323 ++++---- src/FrostFS.SDK.Tests/Smoke/PoolSmokeTests.cs | 585 +++++++++++++++ .../Smoke/SmokeClientTests.cs | 709 ++++++++++++++++++ .../{ => Smoke}/SmokeTestsBase.cs | 2 +- .../{ => Unit}/ContainerTest.cs | 12 +- .../{ => Unit}/ContainerTestsBase.cs | 10 +- .../{ => Unit}/NetworkTest.cs | 70 +- .../{ => Unit}/NetworkTestsBase.cs | 10 +- .../{ => Unit}/ObjectTest.cs | 98 +-- .../{ => Unit}/ObjectTestsBase.cs | 2 +- .../{ => Unit}/SessionTests.cs | 21 +- .../{ => Unit}/SessionTestsBase.cs | 10 +- 62 files changed, 2742 insertions(+), 963 deletions(-) create mode 100644 src/FrostFS.SDK.Client/Models/Object/FrostFsHeaderResult.cs create mode 100644 src/FrostFS.SDK.Client/Models/Object/FrostFsSplitInfo.cs delete mode 100644 src/FrostFS.SDK.Client/Parameters/Credentials.cs delete mode 100644 src/FrostFS.SDK.Client/Parameters/IContext.cs create mode 100644 src/FrostFS.SDK.Client/Parameters/PrmApeChainAdd.cs delete mode 100644 src/FrostFS.SDK.Client/Parameters/PrmApeRemoveAdd.cs delete mode 100644 src/FrostFS.SDK.Client/Parameters/PrmBalance.cs delete mode 100644 src/FrostFS.SDK.Client/Parameters/PrmBase.cs delete mode 100644 src/FrostFS.SDK.Client/Parameters/PrmNetmapSnapshot.cs delete mode 100644 src/FrostFS.SDK.Client/Parameters/PrmNetworkSettings.cs delete mode 100644 src/FrostFS.SDK.Client/Parameters/PrmNodeInfo.cs create mode 100644 src/FrostFS.SDK.Client/Parameters/PutObjectContext.cs delete mode 100644 src/FrostFS.SDK.Tests/GlobalSuppressions.cs create mode 100644 src/FrostFS.SDK.Tests/Multithread/MultiThreadTestsBase.cs rename src/FrostFS.SDK.Tests/{PoolSmokeTests.cs => Multithread/MultithreadPoolSmokeTests.cs} (72%) rename src/FrostFS.SDK.Tests/{SmokeClientTests.cs => Multithread/MultithreadSmokeClientTests.cs} (67%) create mode 100644 src/FrostFS.SDK.Tests/Smoke/PoolSmokeTests.cs create mode 100644 src/FrostFS.SDK.Tests/Smoke/SmokeClientTests.cs rename src/FrostFS.SDK.Tests/{ => Smoke}/SmokeTestsBase.cs (94%) rename src/FrostFS.SDK.Tests/{ => Unit}/ContainerTest.cs (89%) rename src/FrostFS.SDK.Tests/{ => Unit}/ContainerTestsBase.cs (78%) rename src/FrostFS.SDK.Tests/{ => Unit}/NetworkTest.cs (81%) rename src/FrostFS.SDK.Tests/{ => Unit}/NetworkTestsBase.cs (79%) rename src/FrostFS.SDK.Tests/{ => Unit}/ObjectTest.cs (76%) rename src/FrostFS.SDK.Tests/{ => Unit}/ObjectTestsBase.cs (98%) rename src/FrostFS.SDK.Tests/{ => Unit}/SessionTests.cs (78%) rename src/FrostFS.SDK.Tests/{ => Unit}/SessionTestsBase.cs (81%) diff --git a/src/FrostFS.SDK.Client/FrostFSClient.cs b/src/FrostFS.SDK.Client/FrostFSClient.cs index e73ba49..4b42fab 100644 --- a/src/FrostFS.SDK.Client/FrostFSClient.cs +++ b/src/FrostFS.SDK.Client/FrostFSClient.cs @@ -49,7 +49,7 @@ public class FrostFSClient : IFrostFSClient internal ClientContext ClientCtx { get; set; } - public static IFrostFSClient GetSingleOwnerInstance(IOptions clientOptions, GrpcChannelOptions? channelOptions = null) + public static IFrostFSClient GetInstance(IOptions clientOptions, GrpcChannelOptions? channelOptions = null) { return new FrostFSClient(clientOptions, channelOptions); } @@ -170,229 +170,134 @@ public class FrostFSClient : IFrostFSClient } #region ApeManagerImplementation - public Task> AddChainAsync(PrmApeChainAdd args) + public Task> AddChainAsync(PrmApeChainAdd args, CallContext ctx) { - if (args is null) - { - throw new ArgumentNullException(nameof(args)); - } - - var service = GetApeManagerService(); - return service.AddChainAsync(args); + return GetApeManagerService().AddChainAsync(args, ctx); } - public Task RemoveChainAsync(PrmApeChainRemove args) + public Task RemoveChainAsync(PrmApeChainRemove args, CallContext ctx) { - if (args is null) - { - throw new ArgumentNullException(nameof(args)); - } - - var service = GetApeManagerService(); - return service.RemoveChainAsync(args); + return GetApeManagerService().RemoveChainAsync(args, ctx); } - public Task ListChainAsync(PrmApeChainList args) + public Task ListChainAsync(PrmApeChainList args, CallContext ctx) { - if (args is null) - throw new ArgumentNullException(nameof(args)); - - var service = GetApeManagerService(); - return service.ListChainAsync(args); + return GetApeManagerService().ListChainAsync(args, ctx); } #endregion #region ContainerImplementation - public Task GetContainerAsync(PrmContainerGet args) + public Task GetContainerAsync(PrmContainerGet args, CallContext ctx) { - if (args is null) - throw new ArgumentNullException(nameof(args)); - - var service = GetContainerService(); - return service.GetContainerAsync(args); + return GetContainerService().GetContainerAsync(args, ctx); } - public IAsyncEnumerable ListContainersAsync(PrmContainerGetAll? args = null) + public IAsyncEnumerable ListContainersAsync(PrmContainerGetAll args, CallContext ctx) { - args ??= new PrmContainerGetAll(); - var service = GetContainerService(); - return service.ListContainersAsync(args); + return GetContainerService().ListContainersAsync(args, ctx); } - public Task CreateContainerAsync(PrmContainerCreate args) + public Task CreateContainerAsync(PrmContainerCreate args, CallContext ctx) { - if (args is null) - throw new ArgumentNullException(nameof(args)); - - var service = GetContainerService(); - return service.CreateContainerAsync(args); + return GetContainerService().CreateContainerAsync(args, ctx); } - public Task DeleteContainerAsync(PrmContainerDelete args) + public Task DeleteContainerAsync(PrmContainerDelete args, CallContext ctx) { - if (args is null) - throw new ArgumentNullException(nameof(args)); - - var service = GetContainerService(); - return service.DeleteContainerAsync(args); + return GetContainerService().DeleteContainerAsync(args, ctx); } #endregion #region NetworkImplementation - public Task GetNetmapSnapshotAsync(PrmNetmapSnapshot? args) + public Task GetNetmapSnapshotAsync(CallContext ctx) { - args ??= new PrmNetmapSnapshot(); - var service = GetNetmapService(); - return service.GetNetmapSnapshotAsync(args); + return GetNetmapService().GetNetmapSnapshotAsync(ctx); } - public Task GetNodeInfoAsync(PrmNodeInfo? args) + public Task GetNodeInfoAsync(CallContext ctx) { - args ??= new PrmNodeInfo(); - var service = GetNetmapService(); - return service.GetLocalNodeInfoAsync(args); + return GetNetmapService().GetLocalNodeInfoAsync(ctx); } - public Task GetNetworkSettingsAsync(PrmNetworkSettings? args) + public Task GetNetworkSettingsAsync(CallContext ctx) { - args ??= new PrmNetworkSettings(); - var service = GetNetmapService(); - return service.GetNetworkSettingsAsync(args.Context!); + return GetNetmapService().GetNetworkSettingsAsync(ctx); } #endregion #region ObjectImplementation - public Task GetObjectHeadAsync(PrmObjectHeadGet args) + public Task GetObjectHeadAsync(PrmObjectHeadGet args, CallContext ctx) { - if (args is null) - throw new ArgumentNullException(nameof(args)); - - var service = GetObjectService(); - return service.GetObjectHeadAsync(args); + return GetObjectService().GetObjectHeadAsync(args, ctx); } - public Task GetObjectAsync(PrmObjectGet args) + public Task GetObjectAsync(PrmObjectGet args, CallContext ctx) { - if (args is null) - throw new ArgumentNullException(nameof(args)); - - var service = GetObjectService(); - return service.GetObjectAsync(args); + return GetObjectService().GetObjectAsync(args, ctx); } - public Task GetRangeAsync(PrmRangeGet args) + public Task GetRangeAsync(PrmRangeGet args, CallContext ctx) { - if (args is null) - throw new ArgumentNullException(nameof(args)); - - var service = GetObjectService(); - return service.GetRangeAsync(args); + return GetObjectService().GetRangeAsync(args, ctx); } - public Task[]> GetRangeHashAsync(PrmRangeHashGet args) + public Task[]> GetRangeHashAsync(PrmRangeHashGet args, CallContext ctx) { - if (args is null) - throw new ArgumentNullException(nameof(args)); - - var service = GetObjectService(); - return service.GetRangeHashAsync(args); + return GetObjectService().GetRangeHashAsync(args, ctx); } - public Task PutObjectAsync(PrmObjectPut args) + public Task PutObjectAsync(PrmObjectPut args, CallContext ctx) { - if (args is null) - throw new ArgumentNullException(nameof(args)); - - var service = GetObjectService(); - return service.PutObjectAsync(args); + return GetObjectService().PutObjectAsync(args, ctx); } - public Task PutSingleObjectAsync(PrmSingleObjectPut args) + public Task PutSingleObjectAsync(PrmSingleObjectPut args, CallContext ctx) { - if (args is null) - throw new ArgumentNullException(nameof(args)); - - var service = GetObjectService(); - return service.PutSingleObjectAsync(args); + return GetObjectService().PutSingleObjectAsync(args, ctx); } - public Task PatchObjectAsync(PrmObjectPatch args) + public Task PatchObjectAsync(PrmObjectPatch args, CallContext ctx) { - if (args is null) - { - throw new ArgumentNullException(nameof(args)); - } - - var service = GetObjectService(); - return service.PatchObjectAsync(args); + return GetObjectService().PatchObjectAsync(args, ctx); } - public Task DeleteObjectAsync(PrmObjectDelete args) + public Task DeleteObjectAsync(PrmObjectDelete args, CallContext ctx) { - if (args is null) - throw new ArgumentNullException(nameof(args)); - - var service = GetObjectService(); - return service.DeleteObjectAsync(args); + return GetObjectService().DeleteObjectAsync(args, ctx); } - public IAsyncEnumerable SearchObjectsAsync(PrmObjectSearch args) + public IAsyncEnumerable SearchObjectsAsync(PrmObjectSearch args, CallContext ctx) { - if (args is null) - throw new ArgumentNullException(nameof(args)); - - var service = GetObjectService(); - return service.SearchObjectsAsync(args); + return GetObjectService().SearchObjectsAsync(args, ctx); } #endregion #region Session Implementation - public async Task CreateSessionAsync(PrmSessionCreate args) + public async Task CreateSessionAsync(PrmSessionCreate args, CallContext ctx) { - if (args is null) - throw new ArgumentNullException(nameof(args)); - - var token = await CreateSessionInternalAsync(args).ConfigureAwait(false); + var token = await CreateSessionInternalAsync(args, ctx).ConfigureAwait(false); return new FrostFsSessionToken(token); } - internal Task CreateSessionInternalAsync(PrmSessionCreate args) + internal Task CreateSessionInternalAsync(PrmSessionCreate args, CallContext ctx) { - if (args is null) - throw new ArgumentNullException(nameof(args)); - var service = GetSessionService(); - return service.CreateSessionAsync(args); + return service.CreateSessionAsync(args, ctx); } #endregion #region Accounting Implementation - public async Task GetBalanceAsync(PrmBalance? args) + public async Task GetBalanceAsync(CallContext ctx) { - args ??= new PrmBalance(); - - var service = GetAccouningService(); - return await service.GetBallance(args).ConfigureAwait(false); + return await GetAccouningService().GetBallance(ctx).ConfigureAwait(false); } #endregion - #region ToolsImplementation - public FrostFsObjectId CalculateObjectId(FrostFsObjectHeader header) + private async void CheckFrostFsVersionSupport(CallContext ctx) { - if (header == null) - throw new ArgumentNullException(nameof(header)); - - return ObjectTools.CalculateObjectId(header, this.ClientCtx); - } - #endregion - - private async void CheckFrostFsVersionSupport(CallContext? ctx = default) - { - var args = new PrmNodeInfo(ctx); - var service = GetNetmapService(); - var localNodeInfo = await service.GetLocalNodeInfoAsync(args).ConfigureAwait(false); + var localNodeInfo = await service.GetLocalNodeInfoAsync(ctx).ConfigureAwait(false); if (!localNodeInfo.Version.IsSupported(ClientCtx.Version)) { @@ -559,10 +464,8 @@ public class FrostFSClient : IFrostFSClient public async Task Dial(CallContext ctx) { - var prm = new PrmBalance(ctx); - var service = GetAccouningService(); - _ = await service.GetBallance(prm).ConfigureAwait(false); + _ = await service.GetBallance(ctx).ConfigureAwait(false); return null; } diff --git a/src/FrostFS.SDK.Client/Interfaces/IFrostFSClient.cs b/src/FrostFS.SDK.Client/Interfaces/IFrostFSClient.cs index 8520528..82df872 100644 --- a/src/FrostFS.SDK.Client/Interfaces/IFrostFSClient.cs +++ b/src/FrostFS.SDK.Client/Interfaces/IFrostFSClient.cs @@ -9,61 +9,57 @@ namespace FrostFS.SDK.Client.Interfaces; public interface IFrostFSClient : IDisposable { #region Network - Task GetNetmapSnapshotAsync(PrmNetmapSnapshot? args = null); + Task GetNetmapSnapshotAsync(CallContext ctx); - Task GetNodeInfoAsync(PrmNodeInfo? args = null); + Task GetNodeInfoAsync(CallContext ctx); - Task GetNetworkSettingsAsync(PrmNetworkSettings? args = null); + Task GetNetworkSettingsAsync(CallContext ctx); #endregion #region Session - Task CreateSessionAsync(PrmSessionCreate args); + Task CreateSessionAsync(PrmSessionCreate args, CallContext ctx); #endregion #region ApeManager - Task> AddChainAsync(PrmApeChainAdd args); + Task> AddChainAsync(PrmApeChainAdd args, CallContext ctx); - Task RemoveChainAsync(PrmApeChainRemove args); + Task RemoveChainAsync(PrmApeChainRemove args, CallContext ctx); - Task ListChainAsync(PrmApeChainList args); + Task ListChainAsync(PrmApeChainList args, CallContext ctx); #endregion #region Container - Task GetContainerAsync(PrmContainerGet args); + Task GetContainerAsync(PrmContainerGet args, CallContext ctx); - IAsyncEnumerable ListContainersAsync(PrmContainerGetAll? args = null); + IAsyncEnumerable ListContainersAsync(PrmContainerGetAll args, CallContext ctx); - Task CreateContainerAsync(PrmContainerCreate args); + Task CreateContainerAsync(PrmContainerCreate args, CallContext ctx); - Task DeleteContainerAsync(PrmContainerDelete args); + Task DeleteContainerAsync(PrmContainerDelete args, CallContext ctx); #endregion #region Object - Task GetObjectHeadAsync(PrmObjectHeadGet args); + Task GetObjectHeadAsync(PrmObjectHeadGet args, CallContext ctx); - Task GetObjectAsync(PrmObjectGet args); + Task GetObjectAsync(PrmObjectGet args, CallContext ctx); - Task GetRangeAsync(PrmRangeGet args); + Task GetRangeAsync(PrmRangeGet args, CallContext ctx); - Task[]> GetRangeHashAsync(PrmRangeHashGet args); + Task[]> GetRangeHashAsync(PrmRangeHashGet args, CallContext ctx); - Task PutObjectAsync(PrmObjectPut args); + Task PutObjectAsync(PrmObjectPut args, CallContext ctx); - Task PutSingleObjectAsync(PrmSingleObjectPut args); + Task PutSingleObjectAsync(PrmSingleObjectPut args, CallContext ctx); - Task PatchObjectAsync(PrmObjectPatch args); + Task PatchObjectAsync(PrmObjectPatch args, CallContext ctx); - Task DeleteObjectAsync(PrmObjectDelete args); + Task DeleteObjectAsync(PrmObjectDelete args, CallContext ctx); - IAsyncEnumerable SearchObjectsAsync(PrmObjectSearch args); + IAsyncEnumerable SearchObjectsAsync(PrmObjectSearch args, CallContext ctx); #endregion #region Account - Task GetBalanceAsync(PrmBalance? args = null); - #endregion - - #region Tools - FrostFsObjectId CalculateObjectId(FrostFsObjectHeader header); + Task GetBalanceAsync(CallContext ctx); #endregion public Task Dial(CallContext ctx); diff --git a/src/FrostFS.SDK.Client/Models/Chain/ChainTarget.cs b/src/FrostFS.SDK.Client/Models/Chain/ChainTarget.cs index dbdde51..89b0d8a 100644 --- a/src/FrostFS.SDK.Client/Models/Chain/ChainTarget.cs +++ b/src/FrostFS.SDK.Client/Models/Chain/ChainTarget.cs @@ -36,13 +36,19 @@ public struct FrostFsChainTarget(FrostFsTargetType type, string name) : IEquatab public override readonly bool Equals(object obj) { - var target = (FrostFsChainTarget)obj; - return Equals(target); + if (obj == null || obj is not FrostFsChainTarget) + return false; + + return Equals((FrostFsChainTarget)obj); + } + public readonly bool Equals(FrostFsChainTarget other) + { + return Type == other.Type && Name.Equals(other.Name, StringComparison.Ordinal); } public override readonly int GetHashCode() { - return $"{Name}{Type}".GetHashCode(); + return Name.GetHashCode() ^ (int)Type; } public static bool operator ==(FrostFsChainTarget left, FrostFsChainTarget right) @@ -54,9 +60,4 @@ public struct FrostFsChainTarget(FrostFsTargetType type, string name) : IEquatab { return !(left == right); } - - public readonly bool Equals(FrostFsChainTarget other) - { - return Type == other.Type && Name.Equals(other.Name, StringComparison.Ordinal); - } } diff --git a/src/FrostFS.SDK.Client/Models/Object/FrostFsHeaderResult.cs b/src/FrostFS.SDK.Client/Models/Object/FrostFsHeaderResult.cs new file mode 100644 index 0000000..43ea299 --- /dev/null +++ b/src/FrostFS.SDK.Client/Models/Object/FrostFsHeaderResult.cs @@ -0,0 +1,8 @@ +namespace FrostFS.SDK; + +public class FrostFsHeaderResult +{ + public FrostFsObjectHeader? HeaderInfo { get; internal set; } + + public FrostFsSplitInfo? SplitInfo { get; internal set; } +} diff --git a/src/FrostFS.SDK.Client/Models/Object/FrostFsSplit.cs b/src/FrostFS.SDK.Client/Models/Object/FrostFsSplit.cs index 64e68e2..bd850cb 100644 --- a/src/FrostFS.SDK.Client/Models/Object/FrostFsSplit.cs +++ b/src/FrostFS.SDK.Client/Models/Object/FrostFsSplit.cs @@ -24,5 +24,4 @@ public class FrostFsSplit(SplitId splitId, public FrostFsObjectHeader? ParentHeader { get; set; } = parentHeader; public ReadOnlyCollection? Children { get; } = children; - } diff --git a/src/FrostFS.SDK.Client/Models/Object/FrostFsSplitInfo.cs b/src/FrostFS.SDK.Client/Models/Object/FrostFsSplitInfo.cs new file mode 100644 index 0000000..5030410 --- /dev/null +++ b/src/FrostFS.SDK.Client/Models/Object/FrostFsSplitInfo.cs @@ -0,0 +1,26 @@ +using FrostFS.Object; +using FrostFS.SDK.Cryptography; + +namespace FrostFS.SDK; + +public class FrostFsSplitInfo +{ + private readonly SplitInfo _splitInfo; + + private SplitId? _splitId; + + private FrostFsObjectId? _link; + + private FrostFsObjectId? _lastPart; + + internal FrostFsSplitInfo(SplitInfo splitInfo) + { + _splitInfo = splitInfo; + } + + public SplitId SplitId => _splitId ??= new SplitId(_splitInfo.SplitId.ToUuid()); + + public FrostFsObjectId Link => _link ??= FrostFsObjectId.FromHash(_splitInfo.Link.Value.Span); + + public FrostFsObjectId LastPart => _lastPart ??= FrostFsObjectId.FromHash(_splitInfo.LastPart.Value.Span); +} diff --git a/src/FrostFS.SDK.Client/Parameters/CallContext.cs b/src/FrostFS.SDK.Client/Parameters/CallContext.cs index 05e061c..018b7fc 100644 --- a/src/FrostFS.SDK.Client/Parameters/CallContext.cs +++ b/src/FrostFS.SDK.Client/Parameters/CallContext.cs @@ -3,22 +3,42 @@ using System.Threading; namespace FrostFS.SDK.Client; -public class CallContext() +public readonly struct CallContext(TimeSpan timeout, CancellationToken cancellationToken = default) : IEquatable { + public CancellationToken CancellationToken { get; } = cancellationToken; - // internal Action? PoolErrorHandler { get; set; } + public TimeSpan Timeout { get; } = timeout; - // public FrostFsOwner? OwnerId { get; set; } + internal readonly DateTime? GetDeadline() + { + return Timeout.Ticks > 0 ? DateTime.UtcNow.Add(Timeout) : null; + } - // public FrostFsVersion? Version { get; set; } + public override readonly bool Equals(object obj) + { + if (obj == null || obj is not CallContext) + return false; - public CancellationToken CancellationToken { get; set; } + return Equals((CallContext)obj); + } - public TimeSpan Timeout { get; set; } + public bool Equals(CallContext other) + { + return Timeout == other.Timeout && CancellationToken.Equals(other.CancellationToken); + } - public DateTime? Deadline => Timeout.Ticks > 0 ? DateTime.UtcNow.Add(Timeout) : null; + public override int GetHashCode() + { + return CancellationToken.GetHashCode() ^ Timeout.GetHashCode(); + } - // public Action? Callback { get; set; } + public static bool operator ==(CallContext left, CallContext right) + { + return left.Equals(right); + } - // public Collection Interceptors { get; } = []; + public static bool operator !=(CallContext left, CallContext right) + { + return !(left == right); + } } diff --git a/src/FrostFS.SDK.Client/Parameters/Credentials.cs b/src/FrostFS.SDK.Client/Parameters/Credentials.cs deleted file mode 100644 index 6b712ff..0000000 --- a/src/FrostFS.SDK.Client/Parameters/Credentials.cs +++ /dev/null @@ -1,10 +0,0 @@ -using System.Security.Cryptography; - -namespace FrostFS.SDK.Client; - -public class Credentials(ECDsa key, FrostFsOwner ownerId) -{ - public ECDsa Key { get; } = key; - - public FrostFsOwner OwnerId { get; } = ownerId; -} diff --git a/src/FrostFS.SDK.Client/Parameters/IContext.cs b/src/FrostFS.SDK.Client/Parameters/IContext.cs deleted file mode 100644 index ebf99a9..0000000 --- a/src/FrostFS.SDK.Client/Parameters/IContext.cs +++ /dev/null @@ -1,11 +0,0 @@ -namespace FrostFS.SDK.Client; - -public interface IContext -{ - /// - /// The method call can be extended with additional behavior like canceling by timeout or user's request, - /// callbacks, interceptors. - /// - /// Additional parameters for calling the method - CallContext? Context { get; } -} diff --git a/src/FrostFS.SDK.Client/Parameters/ISessionToken.cs b/src/FrostFS.SDK.Client/Parameters/ISessionToken.cs index 6d07be0..de1a376 100644 --- a/src/FrostFS.SDK.Client/Parameters/ISessionToken.cs +++ b/src/FrostFS.SDK.Client/Parameters/ISessionToken.cs @@ -8,5 +8,5 @@ public interface ISessionToken /// member. The session has a limited validity period, and applies to a strictly defined set of operations. /// /// Instance of the session obtained from the server - FrostFsSessionToken? SessionToken { get; set; } + FrostFsSessionToken? SessionToken { get; } } \ No newline at end of file diff --git a/src/FrostFS.SDK.Client/Parameters/PrmApeChainAdd.cs b/src/FrostFS.SDK.Client/Parameters/PrmApeChainAdd.cs new file mode 100644 index 0000000..adcc1b9 --- /dev/null +++ b/src/FrostFS.SDK.Client/Parameters/PrmApeChainAdd.cs @@ -0,0 +1,43 @@ +namespace FrostFS.SDK.Client; + +public readonly struct PrmApeChainAdd(FrostFsChainTarget target, FrostFsChain chain, string[]? xheaders = null) : System.IEquatable +{ + public FrostFsChainTarget Target { get; } = target; + + public FrostFsChain Chain { get; } = chain; + + /// + /// FrostFS request X-Headers + /// + public string[] XHeaders { get; } = xheaders ?? []; + + public override readonly bool Equals(object obj) + { + if (obj == null || obj is not PrmApeChainAdd) + return false; + + return Equals((PrmApeChainAdd)obj); + } + + public readonly bool Equals(PrmApeChainAdd other) + { + return Target == other.Target + && Chain == other.Chain + && XHeaders == other.XHeaders; + } + + public override readonly int GetHashCode() + { + return Chain.GetHashCode() ^ Target.GetHashCode() ^ XHeaders.GetHashCode(); + } + + public static bool operator ==(PrmApeChainAdd left, PrmApeChainAdd right) + { + return left.Equals(right); + } + + public static bool operator !=(PrmApeChainAdd left, PrmApeChainAdd right) + { + return !(left == right); + } +} diff --git a/src/FrostFS.SDK.Client/Parameters/PrmApeChainList.cs b/src/FrostFS.SDK.Client/Parameters/PrmApeChainList.cs index a9a75bb..a946840 100644 --- a/src/FrostFS.SDK.Client/Parameters/PrmApeChainList.cs +++ b/src/FrostFS.SDK.Client/Parameters/PrmApeChainList.cs @@ -1,6 +1,40 @@ namespace FrostFS.SDK.Client; -public sealed class PrmApeChainList(FrostFsChainTarget target, CallContext? ctx = null) : PrmBase(ctx) +public readonly struct PrmApeChainList(FrostFsChainTarget target, string[]? xheaders = null) : System.IEquatable { public FrostFsChainTarget Target { get; } = target; + + /// + /// FrostFS request X-Headers + /// + public string[] XHeaders { get; } = xheaders ?? []; + + public override readonly bool Equals(object obj) + { + if (obj == null || obj is not PrmApeChainList) + return false; + + return Equals((PrmApeChainList)obj); + } + + public override readonly int GetHashCode() + { + return Target.GetHashCode() ^ XHeaders.GetHashCode(); + } + + public readonly bool Equals(PrmApeChainList other) + { + return Target == other.Target + && XHeaders == other.XHeaders; + } + + public static bool operator ==(PrmApeChainList left, PrmApeChainList right) + { + return left.Equals(right); + } + + public static bool operator !=(PrmApeChainList left, PrmApeChainList right) + { + return !(left == right); + } } diff --git a/src/FrostFS.SDK.Client/Parameters/PrmApeChainRemove.cs b/src/FrostFS.SDK.Client/Parameters/PrmApeChainRemove.cs index 9773e6d..7e31ff4 100644 --- a/src/FrostFS.SDK.Client/Parameters/PrmApeChainRemove.cs +++ b/src/FrostFS.SDK.Client/Parameters/PrmApeChainRemove.cs @@ -1,8 +1,46 @@ namespace FrostFS.SDK.Client; -public sealed class PrmApeChainRemove(FrostFsChainTarget target, FrostFsChain chain, CallContext? ctx = null) : PrmBase(ctx) +public readonly struct PrmApeChainRemove( + FrostFsChainTarget target, + FrostFsChain chain, + string[]? xheaders = null) : System.IEquatable { public FrostFsChainTarget Target { get; } = target; public FrostFsChain Chain { get; } = chain; + + /// + /// FrostFS request X-Headers + /// + public string[] XHeaders { get; } = xheaders ?? []; + + public override readonly bool Equals(object obj) + { + if (obj == null || obj is not PrmApeChainRemove) + return false; + + return Equals((PrmApeChainRemove)obj); + } + + public readonly bool Equals(PrmApeChainRemove other) + { + return Target == other.Target + && Chain == other.Chain + && XHeaders == other.XHeaders; + } + + public override readonly int GetHashCode() + { + return Chain.GetHashCode() ^ Target.GetHashCode() ^ XHeaders.GetHashCode(); + } + + public static bool operator ==(PrmApeChainRemove left, PrmApeChainRemove right) + { + return left.Equals(right); + } + + public static bool operator !=(PrmApeChainRemove left, PrmApeChainRemove right) + { + return !(left == right); + } } diff --git a/src/FrostFS.SDK.Client/Parameters/PrmApeRemoveAdd.cs b/src/FrostFS.SDK.Client/Parameters/PrmApeRemoveAdd.cs deleted file mode 100644 index b74901f..0000000 --- a/src/FrostFS.SDK.Client/Parameters/PrmApeRemoveAdd.cs +++ /dev/null @@ -1,8 +0,0 @@ -namespace FrostFS.SDK.Client; - -public sealed class PrmApeChainAdd(FrostFsChainTarget target, FrostFsChain chain, CallContext? ctx = null) : PrmBase(ctx) -{ - public FrostFsChainTarget Target { get; } = target; - - public FrostFsChain Chain { get; } = chain; -} diff --git a/src/FrostFS.SDK.Client/Parameters/PrmBalance.cs b/src/FrostFS.SDK.Client/Parameters/PrmBalance.cs deleted file mode 100644 index 6544287..0000000 --- a/src/FrostFS.SDK.Client/Parameters/PrmBalance.cs +++ /dev/null @@ -1,5 +0,0 @@ -namespace FrostFS.SDK.Client; - -public sealed class PrmBalance(CallContext? ctx = null) : PrmBase(ctx) -{ -} diff --git a/src/FrostFS.SDK.Client/Parameters/PrmBase.cs b/src/FrostFS.SDK.Client/Parameters/PrmBase.cs deleted file mode 100644 index 092be46..0000000 --- a/src/FrostFS.SDK.Client/Parameters/PrmBase.cs +++ /dev/null @@ -1,14 +0,0 @@ -using System.Collections.Specialized; - -namespace FrostFS.SDK.Client; - -public class PrmBase(CallContext? ctx, NameValueCollection? xheaders = null) : IContext -{ - /// - /// FrostFS request X-Headers - /// - public NameValueCollection XHeaders { get; } = xheaders ?? []; - - /// - public CallContext Context { get; } = ctx ?? new CallContext(); -} diff --git a/src/FrostFS.SDK.Client/Parameters/PrmContainerCreate.cs b/src/FrostFS.SDK.Client/Parameters/PrmContainerCreate.cs index ea29967..d5c6ca0 100644 --- a/src/FrostFS.SDK.Client/Parameters/PrmContainerCreate.cs +++ b/src/FrostFS.SDK.Client/Parameters/PrmContainerCreate.cs @@ -1,17 +1,61 @@ namespace FrostFS.SDK.Client; -public sealed class PrmContainerCreate(FrostFsContainerInfo container, CallContext? ctx = null) : PrmBase(ctx), ISessionToken +public readonly struct PrmContainerCreate( + FrostFsContainerInfo container, + PrmWait waitParams, + FrostFsSessionToken? sessionToken = null, + string[]? xheaders = null) : ISessionToken, System.IEquatable { - public FrostFsContainerInfo Container { get; set; } = container; + public FrostFsContainerInfo Container { get; } = container; /// /// Since the container becomes available with some delay, it needs to poll the container status /// /// Rules for polling the result - public PrmWait? WaitParams { get; set; } + public PrmWait WaitParams { get; } = waitParams; /// /// Blank session token /// - public FrostFsSessionToken? SessionToken { get; set; } + public FrostFsSessionToken? SessionToken { get; } = sessionToken; + + /// + /// FrostFS request X-Headers + /// + public string[] XHeaders { get; } = xheaders ?? []; + + + public override readonly bool Equals(object obj) + { + if (obj == null || obj is not PrmContainerCreate) + return false; + + return Equals((PrmContainerCreate)obj); + } + + public readonly bool Equals(PrmContainerCreate other) + { + return Container == other.Container + && WaitParams == other.WaitParams + && SessionToken == other.SessionToken + && XHeaders == other.XHeaders; + } + + public override readonly int GetHashCode() + { + return Container.GetHashCode() + ^ WaitParams.GetHashCode() + ^ (SessionToken == null ? 0 : SessionToken.GetHashCode()) + ^ XHeaders.GetHashCode(); + } + + public static bool operator ==(PrmContainerCreate left, PrmContainerCreate right) + { + return left.Equals(right); + } + + public static bool operator !=(PrmContainerCreate left, PrmContainerCreate right) + { + return !(left == right); + } } diff --git a/src/FrostFS.SDK.Client/Parameters/PrmContainerDelete.cs b/src/FrostFS.SDK.Client/Parameters/PrmContainerDelete.cs index e6b1d6d..1ad1b33 100644 --- a/src/FrostFS.SDK.Client/Parameters/PrmContainerDelete.cs +++ b/src/FrostFS.SDK.Client/Parameters/PrmContainerDelete.cs @@ -1,14 +1,52 @@ namespace FrostFS.SDK.Client; -public sealed class PrmContainerDelete(FrostFsContainerId containerId, CallContext? ctx = null) : PrmBase(ctx), ISessionToken +public readonly struct PrmContainerDelete( + FrostFsContainerId containerId, + PrmWait waitParams, + FrostFsSessionToken? sessionToken = null, + string[]? xheaders = null) : ISessionToken, System.IEquatable { - public FrostFsContainerId ContainerId { get; set; } = containerId; + public FrostFsContainerId ContainerId { get; } = containerId; /// /// Since the container is removed with some delay, it needs to poll the container status /// /// Rules for polling the result - public PrmWait? WaitParams { get; set; } + public PrmWait WaitParams { get; } = waitParams; - public FrostFsSessionToken? SessionToken { get; set; } + public FrostFsSessionToken? SessionToken { get; } = sessionToken; + + /// + /// FrostFS request X-Headers + /// + public string[] XHeaders { get; } = xheaders ?? []; + + public override readonly bool Equals(object obj) + { + if (obj == null || obj is not PrmContainerDelete) + return false; + + return Equals((PrmContainerDelete)obj); + } + + public readonly bool Equals(PrmContainerDelete other) + { + return ContainerId == other.ContainerId + && WaitParams.Equals(other.WaitParams); + } + + public override int GetHashCode() + { + return ContainerId.GetHashCode() ^ WaitParams.GetHashCode(); + } + + public static bool operator ==(PrmContainerDelete left, PrmContainerDelete right) + { + return left.Equals(right); + } + + public static bool operator !=(PrmContainerDelete left, PrmContainerDelete right) + { + return !(left == right); + } } diff --git a/src/FrostFS.SDK.Client/Parameters/PrmContainerGet.cs b/src/FrostFS.SDK.Client/Parameters/PrmContainerGet.cs index 723a4c2..a2e34ae 100644 --- a/src/FrostFS.SDK.Client/Parameters/PrmContainerGet.cs +++ b/src/FrostFS.SDK.Client/Parameters/PrmContainerGet.cs @@ -1,6 +1,40 @@ namespace FrostFS.SDK.Client; -public sealed class PrmContainerGet(FrostFsContainerId container, CallContext? ctx = null) : PrmBase(ctx) +public readonly struct PrmContainerGet(FrostFsContainerId container, string[]? xheaders = null) : System.IEquatable { - public FrostFsContainerId Container { get; set; } = container; + public FrostFsContainerId Container { get; } = container; + + /// + /// FrostFS request X-Headers + /// + public string[] XHeaders { get; } = xheaders ?? []; + + public override readonly bool Equals(object obj) + { + if (obj == null || obj is not PrmContainerGet) + return false; + + return Equals((PrmContainerGet)obj); + } + + public readonly bool Equals(PrmContainerGet other) + { + return GetHashCode() == other.GetHashCode(); + } + + public override readonly int GetHashCode() + { + return Container.GetHashCode() + ^ XHeaders.GetHashCode(); + } + + public static bool operator ==(PrmContainerGet left, PrmContainerGet right) + { + return left.Equals(right); + } + + public static bool operator !=(PrmContainerGet left, PrmContainerGet right) + { + return !(left == right); + } } diff --git a/src/FrostFS.SDK.Client/Parameters/PrmContainerGetAll.cs b/src/FrostFS.SDK.Client/Parameters/PrmContainerGetAll.cs index 66e2f9b..50b408e 100644 --- a/src/FrostFS.SDK.Client/Parameters/PrmContainerGetAll.cs +++ b/src/FrostFS.SDK.Client/Parameters/PrmContainerGetAll.cs @@ -1,5 +1,39 @@ -namespace FrostFS.SDK.Client; +using System; -public sealed class PrmContainerGetAll(CallContext? ctx = null) : PrmBase(ctx) +namespace FrostFS.SDK.Client; + +public readonly struct PrmContainerGetAll(string[]? xheaders = null) : IEquatable { + /// + /// FrostFS request X-Headers + /// + public string[] XHeaders { get; } = xheaders ?? []; + + public override readonly bool Equals(object obj) + { + if (obj == null || obj is not PrmContainerGetAll) + return false; + + return Equals((PrmContainerGetAll)obj); + } + + public readonly bool Equals(PrmContainerGetAll other) + { + return XHeaders == other.XHeaders; + } + + public override readonly int GetHashCode() + { + return XHeaders.GetHashCode(); + } + + public static bool operator ==(PrmContainerGetAll left, PrmContainerGetAll right) + { + return left.Equals(right); + } + + public static bool operator !=(PrmContainerGetAll left, PrmContainerGetAll right) + { + return !(left == right); + } } diff --git a/src/FrostFS.SDK.Client/Parameters/PrmNetmapSnapshot.cs b/src/FrostFS.SDK.Client/Parameters/PrmNetmapSnapshot.cs deleted file mode 100644 index 06a379c..0000000 --- a/src/FrostFS.SDK.Client/Parameters/PrmNetmapSnapshot.cs +++ /dev/null @@ -1,5 +0,0 @@ -namespace FrostFS.SDK.Client; - -public sealed class PrmNetmapSnapshot(CallContext? ctx = null) : PrmBase(ctx) -{ -} diff --git a/src/FrostFS.SDK.Client/Parameters/PrmNetworkSettings.cs b/src/FrostFS.SDK.Client/Parameters/PrmNetworkSettings.cs deleted file mode 100644 index 9731d4d..0000000 --- a/src/FrostFS.SDK.Client/Parameters/PrmNetworkSettings.cs +++ /dev/null @@ -1,5 +0,0 @@ -namespace FrostFS.SDK.Client; - -public sealed class PrmNetworkSettings(CallContext? ctx = null) : PrmBase(ctx) -{ -} diff --git a/src/FrostFS.SDK.Client/Parameters/PrmNodeInfo.cs b/src/FrostFS.SDK.Client/Parameters/PrmNodeInfo.cs deleted file mode 100644 index e93b94f..0000000 --- a/src/FrostFS.SDK.Client/Parameters/PrmNodeInfo.cs +++ /dev/null @@ -1,5 +0,0 @@ -namespace FrostFS.SDK.Client; - -public sealed class PrmNodeInfo(CallContext? ctx = null) : PrmBase(ctx) -{ -} diff --git a/src/FrostFS.SDK.Client/Parameters/PrmObjectDelete.cs b/src/FrostFS.SDK.Client/Parameters/PrmObjectDelete.cs index 9a42958..fa12755 100644 --- a/src/FrostFS.SDK.Client/Parameters/PrmObjectDelete.cs +++ b/src/FrostFS.SDK.Client/Parameters/PrmObjectDelete.cs @@ -1,11 +1,51 @@ namespace FrostFS.SDK.Client; -public sealed class PrmObjectDelete(FrostFsContainerId containerId, FrostFsObjectId objectId, CallContext? ctx = null) : PrmBase(ctx), ISessionToken +public readonly struct PrmObjectDelete( + FrostFsContainerId containerId, + FrostFsObjectId objectId, + FrostFsSessionToken? sessionToken = null, + string[]? xheaders = null) : ISessionToken, System.IEquatable { - public FrostFsContainerId ContainerId { get; set; } = containerId; + public FrostFsContainerId ContainerId { get; } = containerId; - public FrostFsObjectId ObjectId { get; set; } = objectId; + public FrostFsObjectId ObjectId { get; } = objectId; /// - public FrostFsSessionToken? SessionToken { get; set; } + public FrostFsSessionToken? SessionToken { get; } = sessionToken; + + /// + /// FrostFS request X-Headers + /// + public string[] XHeaders { get; } = xheaders ?? []; + + public override readonly bool Equals(object obj) + { + if (obj == null || obj is not PrmObjectDelete) + return false; + + return Equals((PrmObjectDelete)obj); + } + + public readonly bool Equals(PrmObjectDelete other) + { + return ContainerId == other.ContainerId + && ObjectId == other.ObjectId + && SessionToken == other.SessionToken + && XHeaders == other.XHeaders; + } + + public override readonly int GetHashCode() + { + return ContainerId.GetHashCode() ^ ObjectId.GetHashCode() ^ (SessionToken != null ? SessionToken.GetHashCode() : 1); + } + + public static bool operator ==(PrmObjectDelete left, PrmObjectDelete right) + { + return left.Equals(right); + } + + public static bool operator !=(PrmObjectDelete left, PrmObjectDelete right) + { + return !(left == right); + } } diff --git a/src/FrostFS.SDK.Client/Parameters/PrmObjectGet.cs b/src/FrostFS.SDK.Client/Parameters/PrmObjectGet.cs index a50a657..b5ed7f8 100644 --- a/src/FrostFS.SDK.Client/Parameters/PrmObjectGet.cs +++ b/src/FrostFS.SDK.Client/Parameters/PrmObjectGet.cs @@ -1,11 +1,52 @@ namespace FrostFS.SDK.Client; -public sealed class PrmObjectGet(FrostFsContainerId containerId, FrostFsObjectId objectId, CallContext? ctx = null) : PrmBase(ctx), ISessionToken +public readonly struct PrmObjectGet( + FrostFsContainerId containerId, + FrostFsObjectId objectId, + FrostFsSessionToken? sessionToken = null, + string[]? xheaders = null) : ISessionToken, System.IEquatable { - public FrostFsContainerId ContainerId { get; set; } = containerId; + public FrostFsContainerId ContainerId { get; } = containerId; - public FrostFsObjectId ObjectId { get; set; } = objectId; + public FrostFsObjectId ObjectId { get; } = objectId; /// - public FrostFsSessionToken? SessionToken { get; set; } + public FrostFsSessionToken? SessionToken { get; } = sessionToken; + + /// + /// FrostFS request X-Headers + /// + public string[] XHeaders { get; } = xheaders ?? []; + + public override readonly bool Equals(object obj) + { + if (obj == null || obj is not PrmObjectGet) + return false; + + return Equals((PrmObjectGet)obj); + } + + public override readonly int GetHashCode() + { + return ContainerId.GetHashCode() + ^ ObjectId.GetHashCode() + ^ (SessionToken == null ? 0 : SessionToken.GetHashCode()); + } + + public readonly bool Equals(PrmObjectGet other) + { + return ContainerId == other.ContainerId + && ObjectId == other.ObjectId + && SessionToken == other.SessionToken; + } + + public static bool operator ==(PrmObjectGet left, PrmObjectGet right) + { + return left.Equals(right); + } + + public static bool operator !=(PrmObjectGet left, PrmObjectGet right) + { + return !(left == right); + } } diff --git a/src/FrostFS.SDK.Client/Parameters/PrmObjectHeadGet.cs b/src/FrostFS.SDK.Client/Parameters/PrmObjectHeadGet.cs index 84fed94..15e2a25 100644 --- a/src/FrostFS.SDK.Client/Parameters/PrmObjectHeadGet.cs +++ b/src/FrostFS.SDK.Client/Parameters/PrmObjectHeadGet.cs @@ -1,11 +1,56 @@ namespace FrostFS.SDK.Client; -public sealed class PrmObjectHeadGet(FrostFsContainerId containerId, FrostFsObjectId objectId, CallContext? ctx = null) : PrmBase(ctx), ISessionToken +public readonly struct PrmObjectHeadGet( + FrostFsContainerId containerId, + FrostFsObjectId objectId, + bool raw = false, + FrostFsSessionToken? sessionToken = null, + string[]? xheaders = null) + : ISessionToken, System.IEquatable { - public FrostFsContainerId ContainerId { get; set; } = containerId; + public FrostFsContainerId ContainerId { get; } = containerId; - public FrostFsObjectId ObjectId { get; set; } = objectId; + public FrostFsObjectId ObjectId { get; } = objectId; + + public bool Raw { get; } = raw; /// - public FrostFsSessionToken? SessionToken { get; set; } + public FrostFsSessionToken? SessionToken { get; } = sessionToken; + + /// + /// FrostFS request X-Headers + /// + public string[] XHeaders { get; } = xheaders ?? []; + + public override readonly bool Equals(object obj) + { + if (obj == null || obj is not PrmObjectHeadGet) + return false; + + return Equals((PrmObjectHeadGet)obj); + } + + public readonly bool Equals(PrmObjectHeadGet other) + { + return ContainerId == other.ContainerId + && ObjectId == other.ObjectId + && SessionToken == other.SessionToken; + } + + public override readonly int GetHashCode() + { + return ContainerId.GetHashCode() + ^ ObjectId.GetHashCode() + ^ (SessionToken == null ? 0 : SessionToken.GetHashCode()); + } + + public static bool operator ==(PrmObjectHeadGet left, PrmObjectHeadGet right) + { + return left.Equals(right); + } + + public static bool operator !=(PrmObjectHeadGet left, PrmObjectHeadGet right) + { + return !(left == right); + } } diff --git a/src/FrostFS.SDK.Client/Parameters/PrmObjectPatch.cs b/src/FrostFS.SDK.Client/Parameters/PrmObjectPatch.cs index 2feb84c..7b26f5b 100644 --- a/src/FrostFS.SDK.Client/Parameters/PrmObjectPatch.cs +++ b/src/FrostFS.SDK.Client/Parameters/PrmObjectPatch.cs @@ -2,23 +2,70 @@ namespace FrostFS.SDK.Client; -public sealed class PrmObjectPatch(FrostFsAddress address, CallContext? ctx = null) : PrmBase(ctx), ISessionToken +public readonly struct PrmObjectPatch( + FrostFsAddress address, + FrostFsRange range, + Stream? payload, + int maxChunkLength, + FrostFsSessionToken? sessionToken = null, + bool replaceAttributes = false, + FrostFsAttributePair[]? newAttributes = null, + string[]? xheaders = null) : ISessionToken, System.IEquatable { public FrostFsAddress Address { get; } = address; - public FrostFsRange Range { get; set; } + public FrostFsRange Range { get; } = range; /// /// A stream with source data /// - public Stream? Payload { get; set; } + public Stream? Payload { get; } = payload; - public FrostFsAttributePair[]? NewAttributes { get; set; } + public FrostFsAttributePair[]? NewAttributes { get; } = newAttributes; - public bool ReplaceAttributes { get; set; } + public bool ReplaceAttributes { get; } = replaceAttributes; - public int MaxPayloadPatchChunkLength { get; set; } + public int MaxChunkLength { get; } = maxChunkLength; /// - public FrostFsSessionToken? SessionToken { get; set; } + public FrostFsSessionToken? SessionToken { get; } = sessionToken; + + /// + /// FrostFS request X-Headers + /// + public string[] XHeaders { get; } = xheaders ?? []; + + public override readonly bool Equals(object obj) + { + if (obj == null || obj is not PrmObjectPatch) + return false; + + return Equals((PrmObjectPatch)obj); + } + + public readonly bool Equals(PrmObjectPatch other) + { + return GetHashCode() == other.GetHashCode(); + } + + public override readonly int GetHashCode() + { + return Address.GetHashCode() + ^ Range.GetHashCode() + ^ (Payload == null ? 0 : Payload.GetHashCode()) + ^ (NewAttributes == null ? 0 : NewAttributes.GetHashCode()) + ^ (SessionToken == null ? 0 : SessionToken.GetHashCode()) + ^ (ReplaceAttributes ? 1 : 0) + ^ MaxChunkLength; + } + + public static bool operator ==(PrmObjectPatch left, PrmObjectPatch right) + { + return left.Equals(right); + } + + public static bool operator !=(PrmObjectPatch left, PrmObjectPatch right) + { + return !(left == right); + } } diff --git a/src/FrostFS.SDK.Client/Parameters/PrmObjectPut.cs b/src/FrostFS.SDK.Client/Parameters/PrmObjectPut.cs index 582d3f5..a2198eb 100644 --- a/src/FrostFS.SDK.Client/Parameters/PrmObjectPut.cs +++ b/src/FrostFS.SDK.Client/Parameters/PrmObjectPut.cs @@ -2,19 +2,26 @@ using System.IO; namespace FrostFS.SDK.Client; -public sealed class PrmObjectPut(CallContext? ctx = null) : PrmBase(ctx), ISessionToken +public readonly struct PrmObjectPut( + FrostFsObjectHeader? header, + Stream? payload, + bool clientCut, + int bufferMaxSize = 0, + FrostFsSessionToken? sessionToken = null, + byte[]? customBuffer = null, + string[]? xheaders = null) : ISessionToken, System.IEquatable { /// /// Need to provide values like ContainerId and ObjectType to create and object. /// Optional parameters ike Attributes can be provided as well. /// /// Header with required parameters to create an object - public FrostFsObjectHeader? Header { get; set; } + public FrostFsObjectHeader? Header { get; } = header; /// /// A stream with source data /// - public Stream? Payload { get; set; } + public Stream? Payload { get; } = payload; /// /// Object size is limited. In the data exceeds the limit, the object will be splitted. @@ -22,25 +29,60 @@ public sealed class PrmObjectPut(CallContext? ctx = null) : PrmBase(ctx), ISessi /// as a stream and will be cut on server side. /// /// Is client cut is applied - public bool ClientCut { get; set; } + public bool ClientCut { get; } = clientCut; /// /// Overrides default size of the buffer for stream transferring. /// /// Size of the buffer - public int BufferMaxSize { get; set; } + public int BufferMaxSize { get; } = bufferMaxSize; /// /// Allows to define a buffer for chunks to manage by the memory allocation and releasing. /// - public byte[]? CustomBuffer { get; set; } + public byte[]? CustomBuffer { get; } = customBuffer; /// - public FrostFsSessionToken? SessionToken { get; set; } + public FrostFsSessionToken? SessionToken { get; } = sessionToken; - internal int MaxObjectSizeCache { get; set; } + /// + /// FrostFS request X-Headers + /// + public string[] XHeaders { get; } = xheaders ?? []; - internal ulong CurrentStreamPosition { get; set; } + internal PutObjectContext PutObjectContext { get; } = new(); - internal ulong FullLength { get; set; } + public override readonly bool Equals(object obj) + { + if (obj == null || obj is not PrmObjectPut) + return false; + + return Equals((PrmObjectPut)obj); + } + + public readonly bool Equals(PrmObjectPut other) + { + return GetHashCode() == other.GetHashCode(); + } + + public override readonly int GetHashCode() + { + return BufferMaxSize + ^ (Header == null ? 0 : Header.GetHashCode()) + ^ (Payload == null ? 0 : Payload.GetHashCode()) + ^ (ClientCut ? 1 : 0) + ^ (CustomBuffer == null ? 0 : CustomBuffer.GetHashCode()) + ^ (SessionToken == null ? 0 : SessionToken.GetHashCode()) + ^ XHeaders.GetHashCode(); + } + + public static bool operator ==(PrmObjectPut left, PrmObjectPut right) + { + return left.Equals(right); + } + + public static bool operator !=(PrmObjectPut left, PrmObjectPut right) + { + return !(left == right); + } } diff --git a/src/FrostFS.SDK.Client/Parameters/PrmObjectSearch.cs b/src/FrostFS.SDK.Client/Parameters/PrmObjectSearch.cs index 2e6d3d2..508fbd0 100644 --- a/src/FrostFS.SDK.Client/Parameters/PrmObjectSearch.cs +++ b/src/FrostFS.SDK.Client/Parameters/PrmObjectSearch.cs @@ -1,21 +1,59 @@ -using System.Collections.Generic; +namespace FrostFS.SDK.Client; -namespace FrostFS.SDK.Client; - -public sealed class PrmObjectSearch(FrostFsContainerId containerId, CallContext? ctx = null, params IObjectFilter[] filters) : PrmBase(ctx), ISessionToken +public readonly struct PrmObjectSearch( + FrostFsContainerId containerId, + FrostFsSessionToken? token, + string[]? xheaders = null, + params IObjectFilter[] filters) : ISessionToken, System.IEquatable { /// /// Defines container for the search /// /// - public FrostFsContainerId ContainerId { get; set; } = containerId; + public FrostFsContainerId ContainerId { get; } = containerId; /// /// Defines the search criteria /// /// Collection of filters - public IEnumerable Filters { get; set; } = filters; + public IObjectFilter[] Filters { get; } = filters; /// - public FrostFsSessionToken? SessionToken { get; set; } + public FrostFsSessionToken? SessionToken { get; } = token; + + /// + /// FrostFS request X-Headers + /// + public string[] XHeaders { get; } = xheaders ?? []; + + public override readonly bool Equals(object obj) + { + if (obj == null || obj is not PrmObjectSearch) + return false; + + return Equals((PrmObjectSearch)obj); + } + + public readonly bool Equals(PrmObjectSearch other) + { + return GetHashCode() == other.GetHashCode(); + } + + public override readonly int GetHashCode() + { + return ContainerId.GetHashCode() + ^ Filters.GetHashCode() + ^ (SessionToken == null ? 0 : SessionToken.GetHashCode()) + ^ XHeaders.GetHashCode(); + } + + public static bool operator ==(PrmObjectSearch left, PrmObjectSearch right) + { + return left.Equals(right); + } + + public static bool operator !=(PrmObjectSearch left, PrmObjectSearch right) + { + return !(left == right); + } } diff --git a/src/FrostFS.SDK.Client/Parameters/PrmRangeGet.cs b/src/FrostFS.SDK.Client/Parameters/PrmRangeGet.cs index 60286f4..ecb53ed 100644 --- a/src/FrostFS.SDK.Client/Parameters/PrmRangeGet.cs +++ b/src/FrostFS.SDK.Client/Parameters/PrmRangeGet.cs @@ -1,11 +1,12 @@ namespace FrostFS.SDK.Client; -public sealed class PrmRangeGet( +public readonly struct PrmRangeGet( FrostFsContainerId containerId, FrostFsObjectId objectId, FrostFsRange range, bool raw = false, - CallContext? ctx = null) : PrmBase(ctx), ISessionToken + FrostFsSessionToken? sessionToken = null, + string[]? xheaders = null) : ISessionToken, System.IEquatable { public FrostFsContainerId ContainerId { get; } = containerId; @@ -16,5 +17,41 @@ public sealed class PrmRangeGet( public bool Raw { get; } = raw; /// - public FrostFsSessionToken? SessionToken { get; set; } + public FrostFsSessionToken? SessionToken { get; } = sessionToken; + + /// + /// FrostFS request X-Headers + /// + public string[] XHeaders { get; } = xheaders ?? []; + + public override readonly bool Equals(object obj) + { + if (obj == null || obj is not PrmRangeGet) + return false; + + return Equals((PrmRangeGet)obj); + } + + public readonly bool Equals(PrmRangeGet other) + { + return GetHashCode() == other.GetHashCode(); + } + + public override readonly int GetHashCode() + { + return ContainerId.GetHashCode() + ^ ObjectId.GetHashCode() + ^ Range.GetHashCode() + ^ Raw.GetHashCode(); + } + + public static bool operator ==(PrmRangeGet left, PrmRangeGet right) + { + return left.Equals(right); + } + + public static bool operator !=(PrmRangeGet left, PrmRangeGet right) + { + return !(left == right); + } } diff --git a/src/FrostFS.SDK.Client/Parameters/PrmRangeHashGet.cs b/src/FrostFS.SDK.Client/Parameters/PrmRangeHashGet.cs index 95853d7..0d74008 100644 --- a/src/FrostFS.SDK.Client/Parameters/PrmRangeHashGet.cs +++ b/src/FrostFS.SDK.Client/Parameters/PrmRangeHashGet.cs @@ -1,11 +1,12 @@ namespace FrostFS.SDK.Client; -public sealed class PrmRangeHashGet( +public readonly struct PrmRangeHashGet( FrostFsContainerId containerId, FrostFsObjectId objectId, FrostFsRange[] ranges, byte[] salt, - CallContext? ctx = null) : PrmBase(ctx), ISessionToken + FrostFsSessionToken? sessionToken = null, + string[]? xheaders = null) : ISessionToken, System.IEquatable { public FrostFsContainerId ContainerId { get; } = containerId; @@ -16,5 +17,42 @@ public sealed class PrmRangeHashGet( public byte[] Salt { get; } = salt; /// - public FrostFsSessionToken? SessionToken { get; set; } + public FrostFsSessionToken? SessionToken { get; } = sessionToken; + + /// + /// FrostFS request X-Headers + /// + public string[] XHeaders { get; } = xheaders ?? []; + + public override readonly bool Equals(object obj) + { + if (obj == null || obj is not PrmRangeHashGet) + return false; + + return Equals((PrmRangeHashGet)obj); + } + + public readonly bool Equals(PrmRangeHashGet other) + { + return GetHashCode() == other.GetHashCode(); + } + + public override readonly int GetHashCode() + { + return ContainerId.GetHashCode() + ^ ObjectId.GetHashCode() + ^ Ranges.GetHashCode() + ^ Salt.GetHashCode() + ^ (SessionToken == null ? 0 : SessionToken.GetHashCode()); + } + + public static bool operator ==(PrmRangeHashGet left, PrmRangeHashGet right) + { + return left.Equals(right); + } + + public static bool operator !=(PrmRangeHashGet left, PrmRangeHashGet right) + { + return !(left == right); + } } diff --git a/src/FrostFS.SDK.Client/Parameters/PrmSessionCreate.cs b/src/FrostFS.SDK.Client/Parameters/PrmSessionCreate.cs index 7fdc3de..5a89ebf 100644 --- a/src/FrostFS.SDK.Client/Parameters/PrmSessionCreate.cs +++ b/src/FrostFS.SDK.Client/Parameters/PrmSessionCreate.cs @@ -1,6 +1,40 @@ namespace FrostFS.SDK.Client; -public sealed class PrmSessionCreate(ulong expiration, CallContext? ctx = null) : PrmBase(ctx) +public readonly struct PrmSessionCreate(ulong expiration, string[]? xheaders = null) : System.IEquatable { - public ulong Expiration { get; set; } = expiration; + public ulong Expiration { get; } = expiration; + + /// + /// FrostFS request X-Headers + /// + public string[] XHeaders { get; } = xheaders ?? []; + + public override readonly bool Equals(object obj) + { + if (obj == null || obj is not PrmSessionCreate) + return false; + + return Equals((PrmSessionCreate)obj); + } + + public override readonly int GetHashCode() + { + return Expiration.GetHashCode() ^ XHeaders.GetHashCode(); + } + + public readonly bool Equals(PrmSessionCreate other) + { + return Expiration == other.Expiration + && XHeaders == other.XHeaders; + } + + public static bool operator ==(PrmSessionCreate left, PrmSessionCreate right) + { + return left.Equals(right); + } + + public static bool operator !=(PrmSessionCreate left, PrmSessionCreate right) + { + return !(left == right); + } } diff --git a/src/FrostFS.SDK.Client/Parameters/PrmSingleObjectPut.cs b/src/FrostFS.SDK.Client/Parameters/PrmSingleObjectPut.cs index 6e5d180..6ca73df 100644 --- a/src/FrostFS.SDK.Client/Parameters/PrmSingleObjectPut.cs +++ b/src/FrostFS.SDK.Client/Parameters/PrmSingleObjectPut.cs @@ -1,9 +1,46 @@ namespace FrostFS.SDK.Client; -public sealed class PrmSingleObjectPut(FrostFsObject frostFsObject, CallContext? ctx = null) : PrmBase(ctx), ISessionToken +public struct PrmSingleObjectPut( + FrostFsObject frostFsObject, + string[]? xheaders = null) : ISessionToken, System.IEquatable { public FrostFsObject FrostFsObject { get; set; } = frostFsObject; /// public FrostFsSessionToken? SessionToken { get; set; } + + /// + /// FrostFS request X-Headers + /// + public string[] XHeaders { get; } = xheaders ?? []; + + public override readonly bool Equals(object obj) + { + if (obj == null || obj is not PrmSingleObjectPut) + return false; + + return Equals((PrmSingleObjectPut)obj); + } + + public override readonly int GetHashCode() + { + return FrostFsObject.GetHashCode() + ^ (SessionToken == null ? 0 : SessionToken.GetHashCode()); + } + + public readonly bool Equals(PrmSingleObjectPut other) + { + return FrostFsObject == other.FrostFsObject + && SessionToken == other.SessionToken; + } + + public static bool operator ==(PrmSingleObjectPut left, PrmSingleObjectPut right) + { + return left.Equals(right); + } + + public static bool operator !=(PrmSingleObjectPut left, PrmSingleObjectPut right) + { + return !(left == right); + } } diff --git a/src/FrostFS.SDK.Client/Parameters/PrmWait.cs b/src/FrostFS.SDK.Client/Parameters/PrmWait.cs index 047f446..2090ef3 100644 --- a/src/FrostFS.SDK.Client/Parameters/PrmWait.cs +++ b/src/FrostFS.SDK.Client/Parameters/PrmWait.cs @@ -2,7 +2,7 @@ namespace FrostFS.SDK.Client; -public class PrmWait(TimeSpan timeout, TimeSpan pollInterval) +public readonly struct PrmWait(TimeSpan timeout, TimeSpan pollInterval) : IEquatable { private static TimeSpan DefaultTimeout = TimeSpan.FromSeconds(120); private static TimeSpan DefaultPollInterval = TimeSpan.FromSeconds(5); @@ -13,12 +13,40 @@ public class PrmWait(TimeSpan timeout, TimeSpan pollInterval) public static PrmWait DefaultParams { get; } = new PrmWait(DefaultTimeout, DefaultPollInterval); - public TimeSpan Timeout { get; set; } = timeout.Ticks == 0 ? DefaultTimeout : timeout; + public TimeSpan Timeout { get; } = timeout.Ticks == 0 ? DefaultTimeout : timeout; - public TimeSpan PollInterval { get; set; } = pollInterval.Ticks == 0 ? DefaultPollInterval : pollInterval; + public TimeSpan PollInterval { get; } = pollInterval.Ticks == 0 ? DefaultPollInterval : pollInterval; - public DateTime GetDeadline() + public readonly DateTime GetDeadline() { return DateTime.UtcNow.AddTicks(Timeout.Ticks); } + + public override readonly bool Equals(object obj) + { + if (obj == null || obj is not PrmWait) + return false; + + return Equals((PrmWait)obj); + } + + public override readonly int GetHashCode() + { + return DefaultTimeout.GetHashCode() ^ DefaultPollInterval.GetHashCode(); + } + + public readonly bool Equals(PrmWait other) + { + return Timeout == other.Timeout && PollInterval == other.PollInterval; + } + + public static bool operator ==(PrmWait left, PrmWait right) + { + return left.Equals(right); + } + + public static bool operator !=(PrmWait left, PrmWait right) + { + return !(left == right); + } } diff --git a/src/FrostFS.SDK.Client/Parameters/PutObjectContext.cs b/src/FrostFS.SDK.Client/Parameters/PutObjectContext.cs new file mode 100644 index 0000000..2976ec5 --- /dev/null +++ b/src/FrostFS.SDK.Client/Parameters/PutObjectContext.cs @@ -0,0 +1,10 @@ +namespace FrostFS.SDK.Client; + +internal sealed class PutObjectContext +{ + internal int MaxObjectSizeCache { get; set; } + + internal ulong CurrentStreamPosition { get; set; } + + internal ulong FullLength { get; set; } +} diff --git a/src/FrostFS.SDK.Client/Pool/ClientWrapper.cs b/src/FrostFS.SDK.Client/Pool/ClientWrapper.cs index de984d6..4f8e70c 100644 --- a/src/FrostFS.SDK.Client/Pool/ClientWrapper.cs +++ b/src/FrostFS.SDK.Client/Pool/ClientWrapper.cs @@ -83,8 +83,7 @@ public class ClientWrapper : ClientStatusMonitor try { - var prmNodeInfo = new PrmNodeInfo(ctx); - var response = await Client!.GetNodeInfoAsync(prmNodeInfo).ConfigureAwait(false); + var response = await Client!.GetNodeInfoAsync(ctx).ConfigureAwait(false); return false; } catch (RpcException) @@ -105,11 +104,7 @@ public class ClientWrapper : ClientStatusMonitor { client = new(WrapperPrm, sessionCache); - var dialCtx = new CallContext - { - Timeout = TimeSpan.FromTicks((long)WrapperPrm.DialTimeout), - CancellationToken = ctx.CancellationToken - }; + var dialCtx = new CallContext(TimeSpan.FromTicks((long)WrapperPrm.DialTimeout), ctx.CancellationToken); var error = await client.Dial(ctx).ConfigureAwait(false); if (!string.IsNullOrEmpty(error)) @@ -132,8 +127,7 @@ public class ClientWrapper : ClientStatusMonitor try { - var prmNodeInfo = new PrmNodeInfo(ctx); - var res = await Client.GetNodeInfoAsync(prmNodeInfo).ConfigureAwait(false); + var res = await Client.GetNodeInfoAsync(ctx).ConfigureAwait(false); } catch (FrostFsException) { diff --git a/src/FrostFS.SDK.Client/Pool/Pool.cs b/src/FrostFS.SDK.Client/Pool/Pool.cs index acb60b9..7df0d40 100644 --- a/src/FrostFS.SDK.Client/Pool/Pool.cs +++ b/src/FrostFS.SDK.Client/Pool/Pool.cs @@ -185,7 +185,7 @@ public partial class Pool : IFrostFSClient InnerPools = inner; - var res = await GetNetworkSettingsAsync(new PrmNetworkSettings(ctx)).ConfigureAwait(false); + var res = await GetNetworkSettingsAsync(default).ConfigureAwait(false); MaxObjectSize = res.MaxObjectSize; @@ -312,7 +312,7 @@ public partial class Pool : IFrostFSClient private static async Task InitSessionForDuration(CallContext ctx, ClientWrapper cw, ulong duration, ECDsa key, bool clientCut) { var client = cw.Client; - var networkInfo = await client!.GetNetworkSettingsAsync(new PrmNetworkSettings(ctx)).ConfigureAwait(false); + var networkInfo = await client!.GetNetworkSettingsAsync(ctx).ConfigureAwait(false); var epoch = networkInfo.Epoch; @@ -320,9 +320,9 @@ public partial class Pool : IFrostFSClient ? ulong.MaxValue : epoch + duration; - var prmSessionCreate = new PrmSessionCreate(exp, ctx); + var prmSessionCreate = new PrmSessionCreate(exp); - return await client.CreateSessionAsync(prmSessionCreate).ConfigureAwait(false); + return await client.CreateSessionAsync(prmSessionCreate, ctx).ConfigureAwait(false); } internal static string FormCacheKey(string address, string key) @@ -507,139 +507,137 @@ public partial class Pool : IFrostFSClient return statistics; } - public async Task GetNetmapSnapshotAsync(PrmNetmapSnapshot? args = null) + public async Task GetNetmapSnapshotAsync(CallContext ctx) { var client = Connection(); - args ??= new(); - - return await client.Client!.GetNetmapSnapshotAsync(args).ConfigureAwait(false); + return await client.Client!.GetNetmapSnapshotAsync(ctx).ConfigureAwait(false); } - public async Task GetNodeInfoAsync(PrmNodeInfo? args = null) + public async Task GetNodeInfoAsync(CallContext ctx) { var client = Connection(); - return await client.Client!.GetNodeInfoAsync(args).ConfigureAwait(false); + return await client.Client!.GetNodeInfoAsync(ctx).ConfigureAwait(false); } - public async Task GetNetworkSettingsAsync(PrmNetworkSettings? args = null) + public async Task GetNetworkSettingsAsync(CallContext ctx) { var client = Connection(); - return await client.Client!.GetNetworkSettingsAsync(args).ConfigureAwait(false); + return await client.Client!.GetNetworkSettingsAsync(ctx).ConfigureAwait(false); } - public async Task CreateSessionAsync(PrmSessionCreate args) + public async Task CreateSessionAsync(PrmSessionCreate args, CallContext ctx) { var client = Connection(); - return await client.Client!.CreateSessionAsync(args).ConfigureAwait(false); + return await client.Client!.CreateSessionAsync(args, ctx).ConfigureAwait(false); } - public async Task> AddChainAsync(PrmApeChainAdd args) + public async Task> AddChainAsync(PrmApeChainAdd args, CallContext ctx) { var client = Connection(); - return await client.Client!.AddChainAsync(args).ConfigureAwait(false); + return await client.Client!.AddChainAsync(args, ctx).ConfigureAwait(false); } - public async Task RemoveChainAsync(PrmApeChainRemove args) + public async Task RemoveChainAsync(PrmApeChainRemove args, CallContext ctx) { var client = Connection(); - await client.Client!.RemoveChainAsync(args).ConfigureAwait(false); + await client.Client!.RemoveChainAsync(args, ctx).ConfigureAwait(false); } - public async Task ListChainAsync(PrmApeChainList args) + public async Task ListChainAsync(PrmApeChainList args, CallContext ctx) { var client = Connection(); - return await client.Client!.ListChainAsync(args).ConfigureAwait(false); + return await client.Client!.ListChainAsync(args, ctx).ConfigureAwait(false); } - public async Task GetContainerAsync(PrmContainerGet args) + public async Task GetContainerAsync(PrmContainerGet args, CallContext ctx) { var client = Connection(); - return await client.Client!.GetContainerAsync(args).ConfigureAwait(false); + return await client.Client!.GetContainerAsync(args, ctx).ConfigureAwait(false); } - public IAsyncEnumerable ListContainersAsync(PrmContainerGetAll? args = null) + public IAsyncEnumerable ListContainersAsync(PrmContainerGetAll args, CallContext ctx) { var client = Connection(); - return client.Client!.ListContainersAsync(args); + return client.Client!.ListContainersAsync(args, ctx); } - public async Task CreateContainerAsync(PrmContainerCreate args) + public async Task CreateContainerAsync(PrmContainerCreate args, CallContext ctx) { var client = Connection(); - return await client.Client!.CreateContainerAsync(args).ConfigureAwait(false); + return await client.Client!.CreateContainerAsync(args, ctx).ConfigureAwait(false); } - public async Task DeleteContainerAsync(PrmContainerDelete args) + public async Task DeleteContainerAsync(PrmContainerDelete args, CallContext ctx) { var client = Connection(); - await client.Client!.DeleteContainerAsync(args).ConfigureAwait(false); + await client.Client!.DeleteContainerAsync(args, ctx).ConfigureAwait(false); } - public async Task GetObjectHeadAsync(PrmObjectHeadGet args) + public async Task GetObjectHeadAsync(PrmObjectHeadGet args, CallContext ctx) { var client = Connection(); - return await client.Client!.GetObjectHeadAsync(args).ConfigureAwait(false); + return await client.Client!.GetObjectHeadAsync(args, ctx).ConfigureAwait(false); } - public async Task GetObjectAsync(PrmObjectGet args) + public async Task GetObjectAsync(PrmObjectGet args, CallContext ctx) { var client = Connection(); - return await client.Client!.GetObjectAsync(args).ConfigureAwait(false); + return await client.Client!.GetObjectAsync(args, ctx).ConfigureAwait(false); } - public async Task PutObjectAsync(PrmObjectPut args) + public async Task PutObjectAsync(PrmObjectPut args, CallContext ctx) { var client = Connection(); - return await client.Client!.PutObjectAsync(args).ConfigureAwait(false); + return await client.Client!.PutObjectAsync(args, ctx).ConfigureAwait(false); } - public async Task PutSingleObjectAsync(PrmSingleObjectPut args) + public async Task PutSingleObjectAsync(PrmSingleObjectPut args, CallContext ctx) { var client = Connection(); - return await client.Client!.PutSingleObjectAsync(args).ConfigureAwait(false); + return await client.Client!.PutSingleObjectAsync(args, ctx).ConfigureAwait(false); } - public async Task PatchObjectAsync(PrmObjectPatch args) + public async Task PatchObjectAsync(PrmObjectPatch args, CallContext ctx) { var client = Connection(); - return await client.Client!.PatchObjectAsync(args).ConfigureAwait(false); + return await client.Client!.PatchObjectAsync(args, ctx).ConfigureAwait(false); } - public async Task GetRangeAsync(PrmRangeGet args) + public async Task GetRangeAsync(PrmRangeGet args, CallContext ctx) { var client = Connection(); - return await client.Client!.GetRangeAsync(args).ConfigureAwait(false); + return await client.Client!.GetRangeAsync(args, ctx).ConfigureAwait(false); } - public async Task[]> GetRangeHashAsync(PrmRangeHashGet args) + public async Task[]> GetRangeHashAsync(PrmRangeHashGet args, CallContext ctx) { var client = Connection(); - return await client.Client!.GetRangeHashAsync(args).ConfigureAwait(false); + return await client.Client!.GetRangeHashAsync(args, ctx).ConfigureAwait(false); } - public async Task PatchAsync(PrmObjectPatch args) + public async Task PatchAsync(PrmObjectPatch args, CallContext ctx) { var client = Connection(); - return await client.Client!.PatchObjectAsync(args).ConfigureAwait(false); + return await client.Client!.PatchObjectAsync(args, ctx).ConfigureAwait(false); } - public async Task DeleteObjectAsync(PrmObjectDelete args) + public async Task DeleteObjectAsync(PrmObjectDelete args, CallContext ctx) { var client = Connection(); - await client.Client!.DeleteObjectAsync(args).ConfigureAwait(false); + await client.Client!.DeleteObjectAsync(args, ctx).ConfigureAwait(false); } - public IAsyncEnumerable SearchObjectsAsync(PrmObjectSearch args) + public IAsyncEnumerable SearchObjectsAsync(PrmObjectSearch args, CallContext ctx) { var client = Connection(); - return client.Client!.SearchObjectsAsync(args); + return client.Client!.SearchObjectsAsync(args, ctx); } - public async Task GetBalanceAsync(PrmBalance? args) + public async Task GetBalanceAsync(CallContext ctx) { var client = Connection(); - return await client.Client!.GetBalanceAsync(args).ConfigureAwait(false); + return await client.Client!.GetBalanceAsync(ctx).ConfigureAwait(false); } protected virtual void Dispose(bool disposing) @@ -661,9 +659,4 @@ public partial class Pool : IFrostFSClient Dispose(disposing: true); GC.SuppressFinalize(this); } - - public FrostFsObjectId CalculateObjectId(FrostFsObjectHeader header) - { - throw new NotImplementedException(); - } } diff --git a/src/FrostFS.SDK.Client/Services/AccountingServiceProvider.cs b/src/FrostFS.SDK.Client/Services/AccountingServiceProvider.cs index bdb8e61..e87674f 100644 --- a/src/FrostFS.SDK.Client/Services/AccountingServiceProvider.cs +++ b/src/FrostFS.SDK.Client/Services/AccountingServiceProvider.cs @@ -16,10 +16,8 @@ internal sealed class AccountingServiceProvider : ContextAccessor _accountingServiceClient = accountingServiceClient; } - internal async Task GetBallance(PrmBalance args) + internal async Task GetBallance(CallContext ctx) { - var ctx = args.Context!; - BalanceRequest request = new() { Body = new() @@ -28,10 +26,10 @@ internal sealed class AccountingServiceProvider : ContextAccessor } }; - request.AddMetaHeader(args.XHeaders); + request.AddMetaHeader([]); request.Sign(ClientContext.Key.ECDsaKey); - var response = await _accountingServiceClient!.BalanceAsync(request, null, ctx.Deadline, ctx.CancellationToken); + var response = await _accountingServiceClient!.BalanceAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken); Verifier.CheckResponse(response); diff --git a/src/FrostFS.SDK.Client/Services/ApeManagerServiceProvider.cs b/src/FrostFS.SDK.Client/Services/ApeManagerServiceProvider.cs index 1c22cdc..0484b16 100644 --- a/src/FrostFS.SDK.Client/Services/ApeManagerServiceProvider.cs +++ b/src/FrostFS.SDK.Client/Services/ApeManagerServiceProvider.cs @@ -16,10 +16,8 @@ internal sealed class ApeManagerServiceProvider : ContextAccessor _apeManagerServiceClient = apeManagerServiceClient; } - internal async Task> AddChainAsync(PrmApeChainAdd args) + internal async Task> AddChainAsync(PrmApeChainAdd args, CallContext ctx) { - var ctx = args.Context!; - AddChainRequest request = new() { Body = new() @@ -32,17 +30,15 @@ internal sealed class ApeManagerServiceProvider : ContextAccessor request.AddMetaHeader(args.XHeaders); request.Sign(ClientContext.Key.ECDsaKey); - var response = await _apeManagerServiceClient!.AddChainAsync(request, null, ctx.Deadline, ctx.CancellationToken); + var response = await _apeManagerServiceClient!.AddChainAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken); Verifier.CheckResponse(response); return response.Body.ChainId.Memory; } - internal async Task RemoveChainAsync(PrmApeChainRemove args) + internal async Task RemoveChainAsync(PrmApeChainRemove args, CallContext ctx) { - var ctx = args.Context!; - RemoveChainRequest request = new() { Body = new() @@ -55,15 +51,13 @@ internal sealed class ApeManagerServiceProvider : ContextAccessor request.AddMetaHeader(args.XHeaders); request.Sign(ClientContext.Key.ECDsaKey); - var response = await _apeManagerServiceClient!.RemoveChainAsync(request, null, ctx.Deadline, ctx.CancellationToken); + var response = await _apeManagerServiceClient!.RemoveChainAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken); Verifier.CheckResponse(response); } - internal async Task ListChainAsync(PrmApeChainList args) + internal async Task ListChainAsync(PrmApeChainList args, CallContext ctx) { - var ctx = args.Context!; - ListChainsRequest request = new() { Body = new() @@ -75,7 +69,7 @@ internal sealed class ApeManagerServiceProvider : ContextAccessor request.AddMetaHeader(args.XHeaders); request.Sign(ClientContext.Key.ECDsaKey); - var response = await _apeManagerServiceClient!.ListChainsAsync(request, null, ctx.Deadline, ctx.CancellationToken); + var response = await _apeManagerServiceClient!.ListChainsAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken); Verifier.CheckResponse(response); diff --git a/src/FrostFS.SDK.Client/Services/ContainerServiceProvider.cs b/src/FrostFS.SDK.Client/Services/ContainerServiceProvider.cs index fcdc0e5..6e02f10 100644 --- a/src/FrostFS.SDK.Client/Services/ContainerServiceProvider.cs +++ b/src/FrostFS.SDK.Client/Services/ContainerServiceProvider.cs @@ -1,6 +1,5 @@ using System; using System.Collections.Generic; -using System.Collections.Specialized; using System.Security.Cryptography; using System.Threading.Tasks; @@ -38,21 +37,19 @@ internal sealed class ContainerServiceProvider(ContainerService.ContainerService return token; } - internal async Task GetContainerAsync(PrmContainerGet args) + internal async Task GetContainerAsync(PrmContainerGet args, CallContext ctx) { GetRequest request = GetContainerRequest(args.Container.ContainerID, args.XHeaders, ClientContext.Key.ECDsaKey); - var response = await service.GetAsync(request, null, args.Context.Deadline, args.Context.CancellationToken); + var response = await service.GetAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken); Verifier.CheckResponse(response); return response.Body.Container.ToModel(); } - internal async IAsyncEnumerable ListContainersAsync(PrmContainerGetAll args) + internal async IAsyncEnumerable ListContainersAsync(PrmContainerGetAll args, CallContext ctx) { - var ctx = args.Context!; - var request = new ListRequest { Body = new() @@ -64,7 +61,7 @@ internal sealed class ContainerServiceProvider(ContainerService.ContainerService request.AddMetaHeader(args.XHeaders); request.Sign(ClientContext.Key.ECDsaKey); - var response = await service.ListAsync(request, null, ctx.Deadline, ctx.CancellationToken); + var response = await service.ListAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken); Verifier.CheckResponse(response); @@ -74,10 +71,8 @@ internal sealed class ContainerServiceProvider(ContainerService.ContainerService } } - internal async Task CreateContainerAsync(PrmContainerCreate args) + internal async Task CreateContainerAsync(PrmContainerCreate args, CallContext ctx) { - var ctx = args.Context!; - var grpcContainer = args.Container.GetContainer(); grpcContainer.OwnerId ??= ClientContext.Owner.OwnerID; @@ -103,7 +98,7 @@ internal sealed class ContainerServiceProvider(ContainerService.ContainerService request.Sign(ClientContext.Key.ECDsaKey); - var response = await service.PutAsync(request, null, ctx.Deadline, ctx.CancellationToken); + var response = await service.PutAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken); Verifier.CheckResponse(response); @@ -112,10 +107,8 @@ internal sealed class ContainerServiceProvider(ContainerService.ContainerService return new FrostFsContainerId(response.Body.ContainerId); } - internal async Task DeleteContainerAsync(PrmContainerDelete args) + internal async Task DeleteContainerAsync(PrmContainerDelete args, CallContext ctx) { - var ctx = args.Context!; - var request = new DeleteRequest { Body = new DeleteRequest.Types.Body @@ -136,7 +129,7 @@ internal sealed class ContainerServiceProvider(ContainerService.ContainerService request.Sign(ClientContext.Key.ECDsaKey); - var response = await service.DeleteAsync(request, null, ctx.Deadline, ctx.CancellationToken); + var response = await service.DeleteAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken); Verifier.CheckResponse(response); @@ -146,7 +139,7 @@ internal sealed class ContainerServiceProvider(ContainerService.ContainerService Verifier.CheckResponse(response); } - private static GetRequest GetContainerRequest(ContainerID id, NameValueCollection? xHeaders, ECDsa key) + private static GetRequest GetContainerRequest(ContainerID id, string[] xHeaders, ECDsa key) { var request = new GetRequest { @@ -168,13 +161,13 @@ internal sealed class ContainerServiceProvider(ContainerService.ContainerService Removed } - private async Task WaitForContainer(WaitExpects expect, ContainerID id, PrmWait? waitParams, CallContext ctx) + private async Task WaitForContainer(WaitExpects expect, ContainerID id, PrmWait waitParams, CallContext ctx) { - var request = GetContainerRequest(id, null, ClientContext.Key.ECDsaKey); + var request = GetContainerRequest(id, [], ClientContext.Key.ECDsaKey); async Task action() { - var response = await service.GetAsync(request, null, ctx.Deadline, ctx.CancellationToken); + var response = await service.GetAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken); Verifier.CheckResponse(response); } @@ -184,9 +177,8 @@ internal sealed class ContainerServiceProvider(ContainerService.ContainerService private static async Task WaitFor( Func action, WaitExpects expect, - PrmWait? waitParams) + PrmWait waitParams) { - waitParams ??= PrmWait.DefaultParams; var deadLine = waitParams.GetDeadline(); while (true) diff --git a/src/FrostFS.SDK.Client/Services/NetmapServiceProvider.cs b/src/FrostFS.SDK.Client/Services/NetmapServiceProvider.cs index 570bd24..a1bf17b 100644 --- a/src/FrostFS.SDK.Client/Services/NetmapServiceProvider.cs +++ b/src/FrostFS.SDK.Client/Services/NetmapServiceProvider.cs @@ -42,19 +42,17 @@ internal sealed class NetmapServiceProvider : ContextAccessor return settings; } - internal async Task GetLocalNodeInfoAsync(PrmNodeInfo args) + internal async Task GetLocalNodeInfoAsync(CallContext ctx) { - var ctx = args.Context!; - var request = new LocalNodeInfoRequest { Body = new LocalNodeInfoRequest.Types.Body { } }; - request.AddMetaHeader(args.XHeaders); + request.AddMetaHeader([]); request.Sign(ClientContext.Key.ECDsaKey); - var response = await netmapServiceClient.LocalNodeInfoAsync(request, null, ctx.Deadline, ctx.CancellationToken); + var response = await netmapServiceClient.LocalNodeInfoAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken); Verifier.CheckResponse(response); @@ -65,10 +63,10 @@ internal sealed class NetmapServiceProvider : ContextAccessor { var request = new NetworkInfoRequest(); - request.AddMetaHeader(null); + request.AddMetaHeader([]); request.Sign(ClientContext.Key.ECDsaKey); - var response = await netmapServiceClient.NetworkInfoAsync(request, null, ctx.Deadline, ctx.CancellationToken) + var response = await netmapServiceClient.NetworkInfoAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken) .ConfigureAwait(false); Verifier.CheckResponse(response); @@ -76,16 +74,14 @@ internal sealed class NetmapServiceProvider : ContextAccessor return response; } - internal async Task GetNetmapSnapshotAsync(PrmNetmapSnapshot args) + internal async Task GetNetmapSnapshotAsync(CallContext ctx) { - var ctx = args.Context!; - var request = new NetmapSnapshotRequest(); - request.AddMetaHeader(args.XHeaders); + request.AddMetaHeader([]); request.Sign(ClientContext.Key.ECDsaKey); - var response = await netmapServiceClient.NetmapSnapshotAsync(request, null, ctx.Deadline, ctx.CancellationToken); + var response = await netmapServiceClient.NetmapSnapshotAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken); Verifier.CheckResponse(response); diff --git a/src/FrostFS.SDK.Client/Services/ObjectServiceProvider.cs b/src/FrostFS.SDK.Client/Services/ObjectServiceProvider.cs index d3c4347..3267ad3 100644 --- a/src/FrostFS.SDK.Client/Services/ObjectServiceProvider.cs +++ b/src/FrostFS.SDK.Client/Services/ObjectServiceProvider.cs @@ -43,10 +43,8 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl return token; } - internal async Task GetObjectHeadAsync(PrmObjectHeadGet args) + internal async Task GetObjectHeadAsync(PrmObjectHeadGet args, CallContext ctx) { - var ctx = args.Context!; - var request = new HeadRequest { Body = new HeadRequest.Types.Body @@ -55,7 +53,8 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl { ContainerId = args.ContainerId.ContainerID, ObjectId = args.ObjectId.ToMessage() - } + }, + Raw = args.Raw } }; @@ -70,17 +69,27 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl request.Sign(ClientContext.Key.ECDsaKey); - var response = await client!.HeadAsync(request, null, ctx.Deadline, ctx.CancellationToken).ConfigureAwait(false); + var response = await client!.HeadAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken).ConfigureAwait(false); Verifier.CheckResponse(response); - return response.Body.Header.Header.ToModel(); + var result = new FrostFsHeaderResult(); + + if (response.Body.Header != null) + { + result.HeaderInfo = response.Body.Header?.Header.ToModel(); + } + + if (response.Body.SplitInfo != null) + { + result.SplitInfo = new FrostFsSplitInfo(response.Body.SplitInfo); + } + + return result; } - internal async Task GetObjectAsync(PrmObjectGet args) + internal async Task GetObjectAsync(PrmObjectGet args, CallContext ctx) { - var ctx = args.Context!; - var request = new GetRequest { Body = new GetRequest.Types.Body @@ -107,10 +116,8 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl return await GetObject(request, ctx).ConfigureAwait(false); } - internal async Task GetRangeAsync(PrmRangeGet args) + internal async Task GetRangeAsync(PrmRangeGet args, CallContext ctx) { - var ctx = args.Context!; - var request = new GetRangeRequest { Body = new GetRangeRequest.Types.Body @@ -140,14 +147,12 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl request.Sign(ClientContext.Key.ECDsaKey); - var call = client.GetRange(request, null, ctx.Deadline, ctx.CancellationToken); + var call = client.GetRange(request, null, ctx.GetDeadline(), ctx.CancellationToken); return new RangeReader(call); } - internal async Task[]> GetRangeHashAsync(PrmRangeHashGet args) + internal async Task[]> GetRangeHashAsync(PrmRangeHashGet args, CallContext ctx) { - var ctx = args.Context!; - var request = new GetRangeHashRequest { Body = new GetRangeHashRequest.Types.Body @@ -182,7 +187,7 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl request.Sign(ClientContext.Key.ECDsaKey); - var response = await client.GetRangeHashAsync(request, null, ctx.Deadline, ctx.CancellationToken); + var response = await client.GetRangeHashAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken); Verifier.CheckResponse(response); @@ -191,11 +196,8 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl return hashCollection; } - - internal async Task DeleteObjectAsync(PrmObjectDelete args) + internal async Task DeleteObjectAsync(PrmObjectDelete args, CallContext ctx) { - var ctx = args.Context!; - var request = new DeleteRequest { Body = new DeleteRequest.Types.Body @@ -218,15 +220,13 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl request.AddMetaHeader(args.XHeaders, protoToken); request.Sign(ClientContext.Key.ECDsaKey); - var response = await client.DeleteAsync(request, null, ctx.Deadline, ctx.CancellationToken); + var response = await client.DeleteAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken); Verifier.CheckResponse(response); } - internal async IAsyncEnumerable SearchObjectsAsync(PrmObjectSearch args) + internal async IAsyncEnumerable SearchObjectsAsync(PrmObjectSearch args, CallContext ctx) { - var ctx = args.Context!; - var request = new SearchRequest { Body = new SearchRequest.Types.Body @@ -265,11 +265,8 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl } } - internal async Task PutObjectAsync(PrmObjectPut args) + internal async Task PutObjectAsync(PrmObjectPut args, CallContext ctx) { - if (args is null) - throw new ArgumentNullException(nameof(args)); - if (args.Header == null) throw new ArgumentNullException(nameof(args), "Header is null"); @@ -278,27 +275,25 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl if (args.ClientCut) { - return await PutClientCutObject(args).ConfigureAwait(false); + return await PutClientCutObject(args, ctx).ConfigureAwait(false); } else { if (args.Header.PayloadLength > 0) - args.FullLength = args.Header.PayloadLength; + args.PutObjectContext.FullLength = args.Header.PayloadLength; else if (args.Payload.CanSeek) - args.FullLength = (ulong)args.Payload.Length; + args.PutObjectContext.FullLength = (ulong)args.Payload.Length; else throw new ArgumentException("The stream does not have a length and payload length is not defined"); - var response = await PutStreamObject(args).ConfigureAwait(false); + var response = await PutStreamObject(args, ctx).ConfigureAwait(false); return response.ObjectId; } } - internal async Task PutSingleObjectAsync(PrmSingleObjectPut args) + internal async Task PutSingleObjectAsync(PrmSingleObjectPut args, CallContext ctx) { - var ctx = args.Context!; - var grpcObject = ObjectTools.CreateObject(args.FrostFsObject, ClientContext); var request = new PutSingleRequest @@ -317,21 +312,19 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl request.Sign(ClientContext.Key.ECDsaKey); - var response = await client.PutSingleAsync(request, null, ctx.Deadline, ctx.CancellationToken).ConfigureAwait(false); + var response = await client.PutSingleAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken).ConfigureAwait(false); Verifier.CheckResponse(response); return FrostFsObjectId.FromHash(grpcObject.ObjectId.Value.Span); } - internal async Task PatchObjectAsync(PrmObjectPatch args) + internal async Task PatchObjectAsync(PrmObjectPatch args, CallContext ctx) { - var ctx = args.Context!; - - var chunkSize = args.MaxPayloadPatchChunkLength; + var chunkSize = args.MaxChunkLength; Stream payload = args.Payload ?? throw new ArgumentNullException(nameof(args), "Stream parameter is null"); - var call = client.Patch(null, ctx.Deadline, ctx.CancellationToken); + var call = client.Patch(null, ctx.GetDeadline(), ctx.CancellationToken); byte[]? chunkBuffer = null; try @@ -415,36 +408,32 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl return response.Body.ObjectId.ToModel(); } - private async Task PutClientCutObject(PrmObjectPut args) + private async Task PutClientCutObject(PrmObjectPut args, CallContext ctx) { - var ctx = args.Context!; - - args.SessionToken ??= await GetDefaultSession(args, ctx).ConfigureAwait(false); - var payloadStream = args.Payload!; var header = args.Header!; if (header.PayloadLength > 0) - args.FullLength = header.PayloadLength; + args.PutObjectContext.FullLength = header.PayloadLength; else if (payloadStream.CanSeek) - args.FullLength = (ulong)payloadStream.Length; + args.PutObjectContext.FullLength = (ulong)payloadStream.Length; else throw new ArgumentException("The stream does not have a length and payload length is not defined"); - if (args.MaxObjectSizeCache == 0) + if (args.PutObjectContext.MaxObjectSizeCache == 0) { - var networkSettings = await ClientContext.Client.GetNetworkSettingsAsync(new PrmNetworkSettings(ctx)) + var networkSettings = await ClientContext.Client.GetNetworkSettingsAsync(ctx) .ConfigureAwait(false); - args.MaxObjectSizeCache = (int)networkSettings.MaxObjectSize; + args.PutObjectContext.MaxObjectSizeCache = (int)networkSettings.MaxObjectSize; } - var restBytes = args.FullLength - args.CurrentStreamPosition; - var objectSize = restBytes > 0 ? (int)Math.Min((ulong)args.MaxObjectSizeCache, restBytes) : args.MaxObjectSizeCache; + var restBytes = args.PutObjectContext.FullLength - args.PutObjectContext.CurrentStreamPosition; + var objectSize = restBytes > 0 ? (int)Math.Min((ulong)args.PutObjectContext.MaxObjectSizeCache, restBytes) : args.PutObjectContext.MaxObjectSizeCache; //define collection capacity var restPart = (restBytes % (ulong)objectSize) > 0 ? 1 : 0; - var objectsCount = args.FullLength > 0 ? (int)(restBytes / (ulong)objectSize) + restPart : 0; + var objectsCount = args.PutObjectContext.FullLength > 0 ? (int)(restBytes / (ulong)objectSize) + restPart : 0; List sentObjectIds = new(objectsCount); @@ -456,13 +445,13 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl args.Header!.Attributes = null; // send all parts except the last one as separate Objects - while (restBytes > (ulong)args.MaxObjectSizeCache) + while (restBytes > (ulong)args.PutObjectContext.MaxObjectSizeCache) { split = new FrostFsSplit(splitId, sentObjectIds.LastOrDefault()); args.Header!.Split = split; - var result = await PutStreamObject(args).ConfigureAwait(false); + var result = await PutStreamObject(args, default).ConfigureAwait(false); sentObjectIds.Add(result.ObjectId); @@ -474,18 +463,18 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl { var largeObjectHeader = new FrostFsObjectHeader(header.ContainerId, FrostFsObjectType.Regular, [.. attributes]) { - PayloadLength = args.FullLength, + PayloadLength = args.PutObjectContext.FullLength, }; args.Header.Split!.ParentHeader = largeObjectHeader; - var result = await PutStreamObject(args).ConfigureAwait(false); + var result = await PutStreamObject(args, default).ConfigureAwait(false); sentObjectIds.Add(result.ObjectId); var linkObject = new FrostFsLinkObject(header.ContainerId, split!.SplitId, largeObjectHeader, sentObjectIds); - _ = await PutSingleObjectAsync(new PrmSingleObjectPut(linkObject, args.Context)).ConfigureAwait(false); + _ = await PutSingleObjectAsync(new PrmSingleObjectPut(linkObject), ctx).ConfigureAwait(false); var parentHeader = args.Header.GetHeader(); @@ -495,7 +484,7 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl // We are here if the payload is placed to one Object. It means no cut action, just simple PUT. args.Header!.Attributes = attributes; - var singlePartResult = await PutStreamObject(args).ConfigureAwait(false); + var singlePartResult = await PutStreamObject(args, default).ConfigureAwait(false); return singlePartResult.ObjectId; } @@ -506,15 +495,13 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl public int ObjectSize = objectSize; } - private async Task PutStreamObject(PrmObjectPut args) + private async Task PutStreamObject(PrmObjectPut args, CallContext ctx) { - var ctx = args.Context!; - var payload = args.Payload!; var chunkSize = args.BufferMaxSize > 0 ? args.BufferMaxSize : Constants.ObjectChunkSize; - var restBytes = args.FullLength - args.CurrentStreamPosition; + var restBytes = args.PutObjectContext.FullLength - args.PutObjectContext.CurrentStreamPosition; chunkSize = (int)Math.Min(restBytes, (ulong)chunkSize); @@ -524,7 +511,7 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl try { // 0 means no limit from client, so server side cut is performed - var objectLimitSize = args.ClientCut ? args.MaxObjectSizeCache : 0; + var objectLimitSize = args.ClientCut ? args.PutObjectContext.MaxObjectSizeCache : 0; if (args.CustomBuffer != null) { @@ -634,7 +621,7 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl throw new ArgumentNullException(nameof(initRequest)); } - var call = client.Put(null, ctx.Deadline, ctx.CancellationToken); + var call = client.Put(null, ctx.GetDeadline(), ctx.CancellationToken); await call.RequestStream.WriteAsync(initRequest).ConfigureAwait(false); @@ -658,7 +645,7 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl if (initRequest is null) throw new ArgumentNullException(nameof(initRequest)); - var call = client.Get(initRequest, null, ctx.Deadline, ctx.CancellationToken); + var call = client.Get(initRequest, null, ctx.GetDeadline(), ctx.CancellationToken); return new ObjectReader(call); } @@ -670,7 +657,7 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl throw new ArgumentNullException(nameof(initRequest)); } - var call = client.Search(initRequest, null, ctx.Deadline, ctx.CancellationToken); + var call = client.Search(initRequest, null, ctx.GetDeadline(), ctx.CancellationToken); return new SearchReader(call); } diff --git a/src/FrostFS.SDK.Client/Services/SessionServiceProvider.cs b/src/FrostFS.SDK.Client/Services/SessionServiceProvider.cs index 859d836..e73a3d3 100644 --- a/src/FrostFS.SDK.Client/Services/SessionServiceProvider.cs +++ b/src/FrostFS.SDK.Client/Services/SessionServiceProvider.cs @@ -14,10 +14,8 @@ internal sealed class SessionServiceProvider : ContextAccessor _sessionServiceClient = sessionServiceClient; } - internal async Task CreateSessionAsync(PrmSessionCreate args) + internal async Task CreateSessionAsync(PrmSessionCreate args, CallContext ctx) { - var ctx = args.Context!; - var request = new CreateRequest { Body = new CreateRequest.Types.Body @@ -30,12 +28,12 @@ internal sealed class SessionServiceProvider : ContextAccessor request.AddMetaHeader(args.XHeaders); request.Sign(ClientContext.Key.ECDsaKey); - return await CreateSession(request, args.Context!).ConfigureAwait(false); + return await CreateSession(request, ctx).ConfigureAwait(false); } internal async Task CreateSession(CreateRequest request, CallContext ctx) { - var response = await _sessionServiceClient!.CreateAsync(request, null, ctx.Deadline, ctx.CancellationToken); + var response = await _sessionServiceClient!.CreateAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken); Verifier.CheckResponse(response); diff --git a/src/FrostFS.SDK.Client/Services/Shared/SessionProvider.cs b/src/FrostFS.SDK.Client/Services/Shared/SessionProvider.cs index e8ff793..da5a26d 100644 --- a/src/FrostFS.SDK.Client/Services/Shared/SessionProvider.cs +++ b/src/FrostFS.SDK.Client/Services/Shared/SessionProvider.cs @@ -18,6 +18,6 @@ internal sealed class SessionProvider(ClientContext envCtx) internal async Task GetDefaultSession(ISessionToken args, CallContext ctx) { - return await envCtx.Client.CreateSessionInternalAsync(new PrmSessionCreate(uint.MaxValue, ctx)).ConfigureAwait(false); + return await envCtx.Client.CreateSessionInternalAsync(new PrmSessionCreate(uint.MaxValue), ctx).ConfigureAwait(false); } } \ No newline at end of file diff --git a/src/FrostFS.SDK.Client/Tools/ObjectTools.cs b/src/FrostFS.SDK.Client/Tools/ObjectTools.cs index eeb06c0..58f9f30 100644 --- a/src/FrostFS.SDK.Client/Tools/ObjectTools.cs +++ b/src/FrostFS.SDK.Client/Tools/ObjectTools.cs @@ -11,16 +11,6 @@ namespace FrostFS.SDK.Client; internal static class ObjectTools { - internal static FrostFsObjectId CalculateObjectId(FrostFsObjectHeader header, ClientContext ctx) - { - var grpcHeader = CreateHeader(header, [], ctx); - - if (header.Split != null) - SetSplitValues(grpcHeader, header.Split, ctx); - - return new ObjectID { Value = grpcHeader.Sha256() }.ToModel(); - } - internal static Object.Object CreateObject(FrostFsObject @object, ClientContext ctx) { @object.Header.OwnerId ??= ctx.Owner; diff --git a/src/FrostFS.SDK.Client/Tools/RequestConstructor.cs b/src/FrostFS.SDK.Client/Tools/RequestConstructor.cs index 64aecc6..00a3916 100644 --- a/src/FrostFS.SDK.Client/Tools/RequestConstructor.cs +++ b/src/FrostFS.SDK.Client/Tools/RequestConstructor.cs @@ -1,6 +1,4 @@ using System; -using System.Collections.Specialized; -using System.Linq; using FrostFS.SDK.Client.Mappers.GRPC; using FrostFS.SDK.Proto.Interfaces; @@ -11,7 +9,7 @@ namespace FrostFS.SDK.Client; public static class RequestConstructor { public static void AddMetaHeader(this IRequest request, - NameValueCollection? xHeaders, + string[] xHeaders, SessionToken? sessionToken = null) { if (request is null) @@ -25,9 +23,15 @@ public static class RequestConstructor if (sessionToken != null) request.MetaHeader.SessionToken = sessionToken; - if (xHeaders != null && xHeaders.Count > 0) - request.MetaHeader.XHeaders.AddRange( - xHeaders.Cast().SelectMany(key => xHeaders.GetValues(key), - (k, v) => new XHeader { Key = k, Value = v })); + if (xHeaders != null && xHeaders.Length > 0) + { + if (xHeaders.Length % 2 != 0) + throw new ArgumentException("xHeaders with odd length"); + + for (var i = 0; i < xHeaders.Length; i += 2) + { + request.MetaHeader.XHeaders.Add(new XHeader { Key = xHeaders[i], Value = xHeaders[i + 1] }); + } + } } } diff --git a/src/FrostFS.SDK.Cryptography/FrostFS.SDK.Cryptography.csproj b/src/FrostFS.SDK.Cryptography/FrostFS.SDK.Cryptography.csproj index 604fe7c..35804f5 100644 --- a/src/FrostFS.SDK.Cryptography/FrostFS.SDK.Cryptography.csproj +++ b/src/FrostFS.SDK.Cryptography/FrostFS.SDK.Cryptography.csproj @@ -16,7 +16,7 @@ - + all runtime; build; native; contentfiles; analyzers; buildtransitive diff --git a/src/FrostFS.SDK.Tests/GlobalSuppressions.cs b/src/FrostFS.SDK.Tests/GlobalSuppressions.cs deleted file mode 100644 index d1eb84b..0000000 --- a/src/FrostFS.SDK.Tests/GlobalSuppressions.cs +++ /dev/null @@ -1,6 +0,0 @@ -// This file is used by Code Analysis to maintain SuppressMessage -// attributes that are applied to this project. -// Project-level suppressions either have no target or are given -// a specific target and scoped to a namespace, type, member, etc. - - diff --git a/src/FrostFS.SDK.Tests/Multithread/MultiThreadTestsBase.cs b/src/FrostFS.SDK.Tests/Multithread/MultiThreadTestsBase.cs new file mode 100644 index 0000000..831f37e --- /dev/null +++ b/src/FrostFS.SDK.Tests/Multithread/MultiThreadTestsBase.cs @@ -0,0 +1,42 @@ +using System.Security.Cryptography; + +using FrostFS.SDK.Client; +using FrostFS.SDK.Cryptography; + +namespace FrostFS.SDK.Tests.Smoke; + +public abstract class MultiThreadTestsBase +{ + private TestNodeInfo[] nodes; + + protected CallContext? Ctx { get; } + + protected MultiThreadTestsBase() + { + nodes = new TestNodeInfo[4]; + + nodes[0] = new(new Uri(""), ""); + nodes[1] = new(new Uri(""), ""); + nodes[2] = new(new Uri(""), ""); + nodes[3] = new(new Uri(""), ""); + } +} + +public class TestNodeInfo +{ + internal Uri Uri; + + protected ECDsa? Key { get; } + + protected FrostFsOwner? OwnerId { get; } + + protected FrostFsVersion? Version { get; } + + public TestNodeInfo(Uri uri, string keyString) + { + Uri = uri; + Key = keyString.LoadWif(); + OwnerId = FrostFsOwner.FromKey(Key); + Version = new FrostFsVersion(2, 13); + } +} diff --git a/src/FrostFS.SDK.Tests/PoolSmokeTests.cs b/src/FrostFS.SDK.Tests/Multithread/MultithreadPoolSmokeTests.cs similarity index 72% rename from src/FrostFS.SDK.Tests/PoolSmokeTests.cs rename to src/FrostFS.SDK.Tests/Multithread/MultithreadPoolSmokeTests.cs index 0a6f2b3..b58cbb1 100644 --- a/src/FrostFS.SDK.Tests/PoolSmokeTests.cs +++ b/src/FrostFS.SDK.Tests/Multithread/MultithreadPoolSmokeTests.cs @@ -6,11 +6,11 @@ using FrostFS.SDK.Cryptography; using Microsoft.Extensions.Options; -namespace FrostFS.SDK.SmokeTests; +namespace FrostFS.SDK.Tests.Smoke; [SuppressMessage("Reliability", "CA2007:Consider calling ConfigureAwait on the awaited task", Justification = "Default Value is correct for tests")] [SuppressMessage("Security", "CA5394:Do not use insecure randomness", Justification = "No secure purpose")] -public class PoolSmokeTests : SmokeTestsBase +public class MultithreadPoolSmokeTests : SmokeTestsBase { private static readonly PrmWait lightWait = new(100, 1); @@ -20,7 +20,7 @@ public class PoolSmokeTests : SmokeTestsBase { Key = keyString.LoadWif(), - NodeParams = [new(1, this.url, 100.0f)], + NodeParams = [new(1, url, 100.0f)], ClientBuilder = null, GracefulCloseOnSwitchTimeout = 30_000_000, Logger = null @@ -34,7 +34,7 @@ public class PoolSmokeTests : SmokeTestsBase using var pool = new Pool(options); - var error = await pool.Dial(new CallContext()); + var error = await pool.Dial(new CallContext(TimeSpan.Zero)); Assert.Null(error); @@ -59,11 +59,11 @@ public class PoolSmokeTests : SmokeTestsBase using var pool = new Pool(options); - var error = await pool.Dial(new CallContext()); + var error = await pool.Dial(new CallContext(TimeSpan.Zero)); Assert.Null(error); - var result = await pool.GetNodeInfoAsync(); + var result = await pool.GetNodeInfoAsync(default); Assert.Equal(2, result.Version.Major); Assert.Equal(13, result.Version.Minor); @@ -82,8 +82,8 @@ public class PoolSmokeTests : SmokeTestsBase { Key = keyString.LoadWif(), NodeParams = [ - new(1, this.url, 100.0f), - new(2, this.url.Replace('0', '1'), 100.0f) + new(1, url, 100.0f), + new(2, url.Replace('0', '1'), 100.0f) ], ClientBuilder = null, GracefulCloseOnSwitchTimeout = 30_000_000, @@ -93,17 +93,15 @@ public class PoolSmokeTests : SmokeTestsBase using var pool = new Pool(options); - var ctx = new CallContext - { - }; + var ctx = new CallContext(TimeSpan.Zero); var error = await pool.Dial(ctx).ConfigureAwait(true); Assert.Null(error); - using var client = FrostFSClient.GetSingleOwnerInstance(GetSingleOwnerOptions(this.keyString, this.url)); + using var client = FrostFSClient.GetInstance(GetSingleOwnerOptions(keyString, url)); - var result = await client.GetNodeInfoAsync(); + var result = await client.GetNodeInfoAsync(default); var statistics = pool.Statistic(); @@ -121,15 +119,15 @@ public class PoolSmokeTests : SmokeTestsBase using var pool = new Pool(options); - var ctx = new CallContext(); + var ctx = new CallContext(TimeSpan.Zero); var error = await pool.Dial(ctx).ConfigureAwait(true); Assert.Null(error); - using var client = FrostFSClient.GetSingleOwnerInstance(GetSingleOwnerOptions(this.keyString, this.url)); + using var client = FrostFSClient.GetInstance(GetSingleOwnerOptions(keyString, url)); - var result = await client.GetNodeInfoAsync(); + var result = await client.GetNodeInfoAsync(default); Assert.False(string.IsNullOrEmpty(callbackText)); Assert.Contains(" took ", callbackText, StringComparison.Ordinal); @@ -142,13 +140,13 @@ public class PoolSmokeTests : SmokeTestsBase using var pool = new Pool(options); - var error = await pool.Dial(new CallContext()).ConfigureAwait(true); + var error = await pool.Dial(new CallContext(TimeSpan.Zero)).ConfigureAwait(true); Assert.Null(error); var prm = new PrmSessionCreate(100); - var token = await pool.CreateSessionAsync(prm).ConfigureAwait(true); + var token = await pool.CreateSessionAsync(prm, default).ConfigureAwait(true); var ownerHash = Base58.Decode(OwnerId!.Value); @@ -164,37 +162,36 @@ public class PoolSmokeTests : SmokeTestsBase using var pool = new Pool(options); - var error = await pool.Dial(new CallContext()).ConfigureAwait(true); + var error = await pool.Dial(new CallContext(TimeSpan.Zero)).ConfigureAwait(true); Assert.Null(error); await Cleanup(pool); - var token = await pool.CreateSessionAsync(new PrmSessionCreate(int.MaxValue)); + var token = await pool.CreateSessionAsync(new PrmSessionCreate(int.MaxValue), default); var createContainerParam = new PrmContainerCreate( - new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1)))); + new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), + PrmWait.DefaultParams, + xheaders: ["key1", "value1"]); - createContainerParam.XHeaders.Add("key1", "value1"); - - var containerId = await pool.CreateContainerAsync(createContainerParam); + var containerId = await pool.CreateContainerAsync(createContainerParam, default); var bytes = GetRandomBytes(1024); - var param = new PrmObjectPut - { - Header = new FrostFsObjectHeader( + var param = new PrmObjectPut( + new FrostFsObjectHeader( containerId: containerId, type: FrostFsObjectType.Regular, [new FrostFsAttributePair("fileName", "test")]), - Payload = new MemoryStream(bytes), - ClientCut = false, - SessionToken = token - }; + bufferMaxSize: 1024, + payload: new MemoryStream(bytes), + clientCut: false, + sessionToken: token); - var objectId = await pool.PutObjectAsync(param).ConfigureAwait(true); + var objectId = await pool.PutObjectAsync(param, default).ConfigureAwait(true); - var @object = await pool.GetObjectAsync(new PrmObjectGet(containerId, objectId)); + var @object = await pool.GetObjectAsync(new PrmObjectGet(containerId, objectId), default); var downloadedBytes = new byte[@object.Header.PayloadLength]; MemoryStream ms = new(downloadedBytes); @@ -217,19 +214,17 @@ public class PoolSmokeTests : SmokeTestsBase using var pool = new Pool(options); - var error = await pool.Dial(new CallContext()).ConfigureAwait(true); + var error = await pool.Dial(new CallContext(TimeSpan.Zero)).ConfigureAwait(true); Assert.Null(error); await Cleanup(pool); var createContainerParam = new PrmContainerCreate( - new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1)))) - { - WaitParams = lightWait - }; + new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), + lightWait); - var containerId = await pool.CreateContainerAsync(createContainerParam); + var containerId = await pool.CreateContainerAsync(createContainerParam, default); var bytes = new byte[] { 1, 2, 3 }; @@ -240,30 +235,28 @@ public class PoolSmokeTests : SmokeTestsBase PayloadLength = 3 }; - var param = new PrmObjectPut - { - Header = new FrostFsObjectHeader( + var param = new PrmObjectPut( + new FrostFsObjectHeader( containerId: containerId, type: FrostFsObjectType.Regular, [new FrostFsAttributePair("fileName", "test")], new FrostFsSplit()), - Payload = new MemoryStream(bytes), - ClientCut = false - }; + payload: new MemoryStream(bytes), + clientCut: false); - var objectId = await pool.PutObjectAsync(param); + var objectId = await pool.PutObjectAsync(param, default); - var head = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId)); + var head = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId, false), default); - var ecdsaKey = this.keyString.LoadWif(); + var ecdsaKey = keyString.LoadWif(); - var networkInfo = await pool.GetNetmapSnapshotAsync(); + var networkInfo = await pool.GetNetmapSnapshotAsync(default); await CheckFilter(pool, containerId, new FilterByContainerId(FrostFsMatchType.Equals, containerId)); await CheckFilter(pool, containerId, new FilterByOwnerId(FrostFsMatchType.Equals, FrostFsOwner.FromKey(ecdsaKey))); - await CheckFilter(pool, containerId, new FilterBySplitId(FrostFsMatchType.Equals, param.Header.Split!.SplitId)); + await CheckFilter(pool, containerId, new FilterBySplitId(FrostFsMatchType.Equals, param.Header!.Split!.SplitId)); await CheckFilter(pool, containerId, new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test")); @@ -286,12 +279,12 @@ public class PoolSmokeTests : SmokeTestsBase { var resultObjectsCount = 0; - PrmObjectSearch searchParam = new(containerId) { Filters = [filter] }; + PrmObjectSearch searchParam = new(containerId, null, [], filter); - await foreach (var objId in pool.SearchObjectsAsync(searchParam)) + await foreach (var objId in pool.SearchObjectsAsync(searchParam, default)) { resultObjectsCount++; - var objHeader = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objId)); + var objHeader = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objId), default); } Assert.True(0 < resultObjectsCount, $"Filter for {filter.Key} doesn't work"); @@ -307,7 +300,7 @@ public class PoolSmokeTests : SmokeTestsBase var options = GetDefaultParams(); - options.Callback = new((CallStatistics cs) => + options.Callback = new((cs) => { callbackInvoked = true; Assert.True(cs.ElapsedMicroSeconds > 0); @@ -315,45 +308,45 @@ public class PoolSmokeTests : SmokeTestsBase using var pool = new Pool(options); - var error = await pool.Dial(new CallContext()).ConfigureAwait(true); + var error = await pool.Dial(new CallContext(TimeSpan.Zero)).ConfigureAwait(true); Assert.Null(error); await Cleanup(pool); - var ctx = new CallContext { }; - var createContainerParam = new PrmContainerCreate( - new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1)), [new("testKey", "testValue")]), ctx); + new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), + PrmWait.DefaultParams, + xheaders: ["testKey", "testValue"]); - var createdContainer = await pool.CreateContainerAsync(createContainerParam); + var createdContainer = await pool.CreateContainerAsync(createContainerParam, default); - var container = await pool.GetContainerAsync(new PrmContainerGet(createdContainer)); + var container = await pool.GetContainerAsync(new PrmContainerGet(createdContainer), default); Assert.NotNull(container); Assert.True(callbackInvoked); var bytes = GetRandomBytes(objectSize); - var param = new PrmObjectPut() - { - Header = new FrostFsObjectHeader( + var param = new PrmObjectPut( + new FrostFsObjectHeader( containerId: createdContainer, type: FrostFsObjectType.Regular, [new FrostFsAttributePair("fileName", "test")]), - Payload = new MemoryStream(bytes), - ClientCut = false - }; + payload: new MemoryStream(bytes), + clientCut: false); - var objectId = await pool.PutObjectAsync(param); + var objectId = await pool.PutObjectAsync(param, default); var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test"); bool hasObject = false; - await foreach (var objId in pool.SearchObjectsAsync(new PrmObjectSearch(createdContainer) { Filters = [filter] })) + await foreach (var objId in pool.SearchObjectsAsync(new PrmObjectSearch(createdContainer, null, [], filter), default)) { hasObject = true; - var objHeader = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(createdContainer, objectId)); + var res = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(createdContainer, objectId), default); + var objHeader = res.HeaderInfo; + Assert.NotNull(objHeader); Assert.Equal((ulong)bytes.Length, objHeader.PayloadLength); Assert.NotNull(objHeader.Attributes); Assert.Single(objHeader.Attributes!); @@ -363,7 +356,7 @@ public class PoolSmokeTests : SmokeTestsBase Assert.True(hasObject); - var @object = await pool.GetObjectAsync(new PrmObjectGet(createdContainer, objectId)); + var @object = await pool.GetObjectAsync(new PrmObjectGet(createdContainer, objectId), default); var downloadedBytes = new byte[@object.Header.PayloadLength]; MemoryStream ms = new(downloadedBytes); @@ -378,7 +371,7 @@ public class PoolSmokeTests : SmokeTestsBase await Cleanup(pool); - await foreach (var _ in pool.ListContainersAsync()) + await foreach (var _ in pool.ListContainersAsync(default, default)) { Assert.Fail("Containers exist"); } @@ -393,52 +386,51 @@ public class PoolSmokeTests : SmokeTestsBase var options = GetDefaultParams(); using var pool = new Pool(options); - options.Callback = new((CallStatistics cs) => Assert.True(cs.ElapsedMicroSeconds > 0)); + options.Callback = new((cs) => Assert.True(cs.ElapsedMicroSeconds > 0)); - var error = await pool.Dial(new CallContext()).ConfigureAwait(true); + var error = await pool.Dial(new CallContext(TimeSpan.Zero)).ConfigureAwait(true); Assert.Null(error); - var token = await pool.CreateSessionAsync(new PrmSessionCreate(int.MaxValue)); + var token = await pool.CreateSessionAsync(new PrmSessionCreate(int.MaxValue), default); await Cleanup(pool); - var ctx = new CallContext - { - Timeout = TimeSpan.FromSeconds(20) - }; + var ctx = new CallContext(TimeSpan.FromSeconds(20)); var createContainerParam = new PrmContainerCreate( - new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), ctx); + new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), + PrmWait.DefaultParams); - var container = await pool.CreateContainerAsync(createContainerParam); + var container = await pool.CreateContainerAsync(createContainerParam, ctx); - var containerInfo = await pool.GetContainerAsync(new PrmContainerGet(container, ctx)); + var containerInfo = await pool.GetContainerAsync(new PrmContainerGet(container), ctx); Assert.NotNull(containerInfo); var bytes = GetRandomBytes(objectSize); - var param = new PrmObjectPut(new CallContext()) - { - Header = new FrostFsObjectHeader( + var param = new PrmObjectPut( + new FrostFsObjectHeader( containerId: container, type: FrostFsObjectType.Regular, [new FrostFsAttributePair("fileName", "test")]), - Payload = new MemoryStream(bytes), - ClientCut = false, - SessionToken = token - }; + payload: new MemoryStream(bytes), + clientCut: false, + sessionToken: token); - var objectId = await pool.PutObjectAsync(param); + var objectId = await pool.PutObjectAsync(param, default); var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test"); bool hasObject = false; - await foreach (var objId in pool.SearchObjectsAsync(new PrmObjectSearch(container) { Filters = [filter], SessionToken = token })) + await foreach (var objId in pool.SearchObjectsAsync(new PrmObjectSearch(container, token, [], filter), default)) { hasObject = true; - var objHeader = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(container, objectId) { SessionToken = token }); + var res = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(container, objectId, false, token), default); + + var objHeader = res.HeaderInfo; + Assert.NotNull(objHeader); Assert.Equal((ulong)bytes.Length, objHeader.PayloadLength); Assert.NotNull(objHeader.Attributes); Assert.Single(objHeader.Attributes); @@ -448,7 +440,7 @@ public class PoolSmokeTests : SmokeTestsBase Assert.True(hasObject); - var @object = await pool.GetObjectAsync(new PrmObjectGet(container, objectId) { SessionToken = token }); + var @object = await pool.GetObjectAsync(new PrmObjectGet(container, objectId, token), default); var downloadedBytes = new byte[@object.Header.PayloadLength]; MemoryStream ms = new(downloadedBytes); @@ -463,7 +455,7 @@ public class PoolSmokeTests : SmokeTestsBase await Cleanup(pool); - await foreach (var _ in pool.ListContainersAsync()) + await foreach (var _ in pool.ListContainersAsync(default, default)) { Assert.Fail("Containers exist"); } @@ -482,52 +474,49 @@ public class PoolSmokeTests : SmokeTestsBase using var pool = new Pool(options); - var error = await pool.Dial(new CallContext()).ConfigureAwait(true); + var error = await pool.Dial(new CallContext(TimeSpan.Zero)).ConfigureAwait(true); Assert.Null(error); await Cleanup(pool); - var createContainerParam = new PrmContainerCreate(new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1)))) - { - WaitParams = lightWait - }; + var createContainerParam = new PrmContainerCreate( + new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), + lightWait); - var containerId = await pool.CreateContainerAsync(createContainerParam); + var containerId = await pool.CreateContainerAsync(createContainerParam, default); - var ctx = new CallContext - { - Timeout = TimeSpan.FromSeconds(10), - }; + var ctx = new CallContext(TimeSpan.FromSeconds(10)); // ctx.Interceptors.Add(new CallbackInterceptor()); - var container = await pool.GetContainerAsync(new PrmContainerGet(containerId, ctx)); + var container = await pool.GetContainerAsync(new PrmContainerGet(containerId), ctx); Assert.NotNull(container); byte[] bytes = GetRandomBytes(objectSize); - var param = new PrmObjectPut - { - Header = new FrostFsObjectHeader( + var param = new PrmObjectPut( + new FrostFsObjectHeader( containerId: containerId, type: FrostFsObjectType.Regular, [new FrostFsAttributePair("fileName", "test")]), - Payload = new MemoryStream(bytes), - ClientCut = true - }; + payload: new MemoryStream(bytes), + clientCut: true); - var objectId = await pool.PutObjectAsync(param); + var objectId = await pool.PutObjectAsync(param, default); var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test"); bool hasObject = false; - await foreach (var objId in pool.SearchObjectsAsync(new PrmObjectSearch(containerId, null, filter))) + await foreach (var objId in pool.SearchObjectsAsync(new PrmObjectSearch(containerId, null, [], filter), default)) { hasObject = true; - var objHeader = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId)); + var res = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId), default); + + var objHeader = res.HeaderInfo; + Assert.NotNull(objHeader); Assert.Equal((ulong)bytes.Length, objHeader.PayloadLength); Assert.NotNull(objHeader.Attributes); Assert.Single(objHeader.Attributes); @@ -537,7 +526,7 @@ public class PoolSmokeTests : SmokeTestsBase Assert.True(hasObject); - var @object = await pool.GetObjectAsync(new PrmObjectGet(containerId, objectId)); + var @object = await pool.GetObjectAsync(new PrmObjectGet(containerId, objectId), default); var downloadedBytes = new byte[@object.Header.PayloadLength]; MemoryStream ms = new(downloadedBytes); @@ -554,7 +543,7 @@ public class PoolSmokeTests : SmokeTestsBase await Cleanup(pool); - await foreach (var cid in pool.ListContainersAsync()) + await foreach (var cid in pool.ListContainersAsync(default, default)) { Assert.Fail($"Container {cid.GetValue()} exist"); } @@ -587,9 +576,9 @@ public class PoolSmokeTests : SmokeTestsBase static async Task Cleanup(Pool pool) { - await foreach (var cid in pool.ListContainersAsync()) + await foreach (var cid in pool.ListContainersAsync(default, default)) { - await pool.DeleteContainerAsync(new PrmContainerDelete(cid) { WaitParams = lightWait }).ConfigureAwait(true); + await pool.DeleteContainerAsync(new PrmContainerDelete(cid, lightWait), default).ConfigureAwait(true); } } } diff --git a/src/FrostFS.SDK.Tests/SmokeClientTests.cs b/src/FrostFS.SDK.Tests/Multithread/MultithreadSmokeClientTests.cs similarity index 67% rename from src/FrostFS.SDK.Tests/SmokeClientTests.cs rename to src/FrostFS.SDK.Tests/Multithread/MultithreadSmokeClientTests.cs index aaf1869..405278c 100644 --- a/src/FrostFS.SDK.Tests/SmokeClientTests.cs +++ b/src/FrostFS.SDK.Tests/Multithread/MultithreadSmokeClientTests.cs @@ -4,23 +4,24 @@ using System.Security.Cryptography; using FrostFS.SDK.Client; using FrostFS.SDK.Client.Interfaces; using FrostFS.SDK.Cryptography; +using FrostFS.SDK.SmokeTests; using Microsoft.Extensions.Options; -namespace FrostFS.SDK.SmokeTests; +namespace FrostFS.SDK.Tests.Smoke; [SuppressMessage("Reliability", "CA2007:Consider calling ConfigureAwait on the awaited task", Justification = "Default Value is correct for tests")] [SuppressMessage("Security", "CA5394:Do not use insecure randomness", Justification = "No secure purpose")] -public class SmokeClientTests : SmokeTestsBase +public class MultithreadSmokeClientTests : SmokeTestsBase { private static readonly PrmWait lightWait = new(100, 1); [Fact] public async void AccountTest() { - using var client = FrostFSClient.GetSingleOwnerInstance(GetClientOptions(this.keyString, this.url)); + using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url)); - var result = await client.GetBalanceAsync(); + var result = await client.GetBalanceAsync(default); Assert.NotNull(result); Assert.True(result.Value == 0); @@ -29,9 +30,9 @@ public class SmokeClientTests : SmokeTestsBase [Fact] public async void NetworkMapTest() { - using var client = FrostFSClient.GetSingleOwnerInstance(GetClientOptions(this.keyString, this.url)); + using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url)); - var result = await client.GetNetmapSnapshotAsync(); + var result = await client.GetNetmapSnapshotAsync(default); Assert.True(result.Epoch > 0); Assert.Single(result.NodeInfoCollection); @@ -49,9 +50,9 @@ public class SmokeClientTests : SmokeTestsBase [Fact] public async void NodeInfoTest() { - using var client = FrostFSClient.GetSingleOwnerInstance(GetClientOptions(this.keyString, this.url)); + using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url)); - var result = await client.GetNodeInfoAsync(); + var result = await client.GetNodeInfoAsync(default); Assert.Equal(2, result.Version.Major); Assert.Equal(13, result.Version.Minor); @@ -64,14 +65,14 @@ public class SmokeClientTests : SmokeTestsBase [Fact] public async void NodeInfoStatisticsTest() { - var options = GetClientOptions(this.keyString, this.url); + var options = GetClientOptions(keyString, url); var callbackContent = string.Empty; options.Value.Callback = (cs) => callbackContent = $"{cs.MethodName} took {cs.ElapsedMicroSeconds} microseconds"; - using var client = FrostFSClient.GetSingleOwnerInstance(options); + using var client = FrostFSClient.GetInstance(options); - var result = await client.GetNodeInfoAsync(); + var result = await client.GetNodeInfoAsync(default); Assert.NotEmpty(callbackContent); } @@ -79,11 +80,9 @@ public class SmokeClientTests : SmokeTestsBase [Fact] public async void GetSessionTest() { - using var client = FrostFSClient.GetSingleOwnerInstance(GetClientOptions(this.keyString, this.url)); + using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url)); - PrmSessionCreate? prm = new(100); - - var token = await client.CreateSessionAsync(prm); + var token = await client.CreateSessionAsync(new(100), default); var ownerHash = Base58.Decode(OwnerId!.Value); @@ -95,35 +94,33 @@ public class SmokeClientTests : SmokeTestsBase [Fact] public async void CreateObjectWithSessionToken() { - using var client = FrostFSClient.GetSingleOwnerInstance(GetClientOptions(this.keyString, this.url)); + using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url)); await Cleanup(client); - var token = await client.CreateSessionAsync(new PrmSessionCreate(int.MaxValue)); + var token = await client.CreateSessionAsync(new PrmSessionCreate(int.MaxValue), default); var createContainerParam = new PrmContainerCreate( - new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1)))); + new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), + PrmWait.DefaultParams, + xheaders: ["key1", "value1"]); - createContainerParam.XHeaders.Add("key1", "value1"); - - var containerId = await client.CreateContainerAsync(createContainerParam); + var containerId = await client.CreateContainerAsync(createContainerParam, default); var bytes = GetRandomBytes(1024); - var param = new PrmObjectPut - { - Header = new FrostFsObjectHeader( + var param = new PrmObjectPut( + new FrostFsObjectHeader( containerId: containerId, type: FrostFsObjectType.Regular, [new FrostFsAttributePair("fileName", "test")]), - Payload = new MemoryStream(bytes), - ClientCut = false, - SessionToken = token - }; + payload: new MemoryStream(bytes), + clientCut: false, + sessionToken: token); - var objectId = await client.PutObjectAsync(param).ConfigureAwait(true); + var objectId = await client.PutObjectAsync(param, default).ConfigureAwait(true); - var @object = await client.GetObjectAsync(new PrmObjectGet(containerId, objectId)) + var @object = await client.GetObjectAsync(new PrmObjectGet(containerId, objectId), default) .ConfigureAwait(true); var downloadedBytes = new byte[@object.Header.PayloadLength]; @@ -143,17 +140,15 @@ public class SmokeClientTests : SmokeTestsBase [Fact] public async void FilterTest() { - using var client = FrostFSClient.GetSingleOwnerInstance(GetClientOptions(this.keyString, this.url)); + using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url)); await Cleanup(client); var createContainerParam = new PrmContainerCreate( - new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1)))) - { - WaitParams = lightWait - }; + new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), + lightWait); - var containerId = await client.CreateContainerAsync(createContainerParam); + var containerId = await client.CreateContainerAsync(createContainerParam, default); var bytes = new byte[] { 1, 2, 3 }; @@ -164,30 +159,28 @@ public class SmokeClientTests : SmokeTestsBase PayloadLength = 3 }; - var param = new PrmObjectPut - { - Header = new FrostFsObjectHeader( + var param = new PrmObjectPut( + new FrostFsObjectHeader( containerId: containerId, type: FrostFsObjectType.Regular, [new FrostFsAttributePair("fileName", "test")], new FrostFsSplit()), - Payload = new MemoryStream(bytes), - ClientCut = false - }; + payload: new MemoryStream(bytes), + clientCut: false); - var objectId = await client.PutObjectAsync(param); + var objectId = await client.PutObjectAsync(param, default); - var head = await client.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId)); + var head = await client.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId), default); - var ecdsaKey = this.keyString.LoadWif(); + var ecdsaKey = keyString.LoadWif(); - var networkInfo = await client.GetNetmapSnapshotAsync(); + var networkInfo = await client.GetNetmapSnapshotAsync(default); await CheckFilter(client, containerId, new FilterByContainerId(FrostFsMatchType.Equals, containerId)); await CheckFilter(client, containerId, new FilterByOwnerId(FrostFsMatchType.Equals, FrostFsOwner.FromKey(ecdsaKey))); - await CheckFilter(client, containerId, new FilterBySplitId(FrostFsMatchType.Equals, param.Header.Split!.SplitId)); + await CheckFilter(client, containerId, new FilterBySplitId(FrostFsMatchType.Equals, param.Header!.Split!.SplitId)); await CheckFilter(client, containerId, new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test")); @@ -210,12 +203,12 @@ public class SmokeClientTests : SmokeTestsBase { var resultObjectsCount = 0; - PrmObjectSearch searchParam = new(containerId) { Filters = [filter] }; + PrmObjectSearch searchParam = new(containerId, null, [], filter); - await foreach (var objId in client.SearchObjectsAsync(searchParam)) + await foreach (var objId in client.SearchObjectsAsync(searchParam, default)) { resultObjectsCount++; - var objHeader = await client.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objId)); + var objHeader = await client.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objId), default); } Assert.True(0 < resultObjectsCount, $"Filter for {filter.Key} doesn't work"); @@ -229,51 +222,53 @@ public class SmokeClientTests : SmokeTestsBase { bool callbackInvoked = false; - var options = GetClientOptions(this.keyString, this.url); + var options = GetClientOptions(keyString, url); - options.Value.Callback = new((CallStatistics cs) => + options.Value.Callback = new((cs) => { callbackInvoked = true; Assert.True(cs.ElapsedMicroSeconds > 0); }); - using var client = FrostFSClient.GetSingleOwnerInstance(options); + using var client = FrostFSClient.GetInstance(options); await Cleanup(client); - var ctx = new CallContext { Timeout = TimeSpan.FromSeconds(20) }; + var ctx = new CallContext(TimeSpan.FromSeconds(20)); var createContainerParam = new PrmContainerCreate( - new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1)), [new("testKey", "testValue")]), ctx); + new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), + PrmWait.DefaultParams, + xheaders: ["testKey", "testValue"]); - var createdContainer = await client.CreateContainerAsync(createContainerParam); + var createdContainer = await client.CreateContainerAsync(createContainerParam, ctx); - var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer)); + var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer), default); Assert.NotNull(container); Assert.True(callbackInvoked); var bytes = GetRandomBytes(objectSize); - var param = new PrmObjectPut - { - Header = new FrostFsObjectHeader( + var param = new PrmObjectPut( + new FrostFsObjectHeader( containerId: createdContainer, type: FrostFsObjectType.Regular, [new FrostFsAttributePair("fileName", "test")]), - Payload = new MemoryStream(bytes), - ClientCut = false - }; + payload: new MemoryStream(bytes), + clientCut: false); - var objectId = await client.PutObjectAsync(param); + var objectId = await client.PutObjectAsync(param, default); var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test"); bool hasObject = false; - await foreach (var objId in client.SearchObjectsAsync(new PrmObjectSearch(createdContainer) { Filters = [filter] })) + await foreach (var objId in client.SearchObjectsAsync(new PrmObjectSearch(createdContainer, null, [], filter), default)) { hasObject = true; - var objHeader = await client.GetObjectHeadAsync(new PrmObjectHeadGet(createdContainer, objectId)); + var res = await client.GetObjectHeadAsync(new PrmObjectHeadGet(createdContainer, objectId), default); + var objHeader = res.HeaderInfo; + Assert.NotNull(objHeader); Assert.Equal((ulong)bytes.Length, objHeader.PayloadLength); Assert.NotNull(objHeader.Attributes); Assert.Single(objHeader.Attributes); @@ -283,7 +278,7 @@ public class SmokeClientTests : SmokeTestsBase Assert.True(hasObject); - var @object = await client.GetObjectAsync(new PrmObjectGet(createdContainer, objectId)); + var @object = await client.GetObjectAsync(new PrmObjectGet(createdContainer, objectId), default); var downloadedBytes = new byte[@object.Header.PayloadLength]; MemoryStream ms = new(downloadedBytes); @@ -298,7 +293,7 @@ public class SmokeClientTests : SmokeTestsBase await Cleanup(client); - await foreach (var _ in client.ListContainersAsync()) + await foreach (var _ in client.ListContainersAsync(default, default)) { Assert.Fail("Containers exist"); } @@ -307,54 +302,53 @@ public class SmokeClientTests : SmokeTestsBase [Fact] public async void PatchTest() { - using var client = FrostFSClient.GetSingleOwnerInstance(GetClientOptions(this.keyString, this.url)); + using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url)); await Cleanup(client); var createContainerParam = new PrmContainerCreate( - new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1)), [new("testKey", "testValue")])); + new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), + PrmWait.DefaultParams, + xheaders: ["testKey", "testValue"]); - var createdContainer = await client.CreateContainerAsync(createContainerParam); + var createdContainer = await client.CreateContainerAsync(createContainerParam, default); - var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer)); + var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer), default); Assert.NotNull(container); var bytes = new byte[1024]; for (int i = 0; i < 1024; i++) { - bytes[i] = (byte)31; + bytes[i] = 31; } - var param = new PrmObjectPut - { - Header = new FrostFsObjectHeader( + var param = new PrmObjectPut( + new FrostFsObjectHeader( containerId: createdContainer, type: FrostFsObjectType.Regular, [new FrostFsAttributePair("fileName", "test")]), - Payload = new MemoryStream(bytes), - ClientCut = false - }; + payload: new MemoryStream(bytes), + clientCut: false); - var objectId = await client.PutObjectAsync(param); + var objectId = await client.PutObjectAsync(param, default); var patch = new byte[16]; for (int i = 0; i < 16; i++) { - patch[i] = (byte)32; + patch[i] = 32; } var range = new FrostFsRange(8, (ulong)patch.Length); - var patchParams = new PrmObjectPatch(new FrostFsAddress(createdContainer, objectId)) - { - Payload = new MemoryStream(patch), - MaxPayloadPatchChunkLength = 32, - Range = range - }; + var patchParams = new PrmObjectPatch( + new FrostFsAddress(createdContainer, objectId), + payload: new MemoryStream(patch), + maxChunkLength: 32, + range: range); - var newIbjId = await client.PatchObjectAsync(patchParams); + var newIbjId = await client.PatchObjectAsync(patchParams, default); - var @object = await client.GetObjectAsync(new PrmObjectGet(createdContainer, newIbjId)); + var @object = await client.GetObjectAsync(new PrmObjectGet(createdContainer, newIbjId), default); var downloadedBytes = new byte[@object.Header.PayloadLength]; MemoryStream ms = new(downloadedBytes); @@ -378,7 +372,7 @@ public class SmokeClientTests : SmokeTestsBase await Cleanup(client); - await foreach (var _ in client.ListContainersAsync()) + await foreach (var _ in client.ListContainersAsync(default, default)) { Assert.Fail("Containers exist"); } @@ -387,16 +381,18 @@ public class SmokeClientTests : SmokeTestsBase [Fact] public async void RangeTest() { - using var client = FrostFSClient.GetSingleOwnerInstance(GetClientOptions(this.keyString, this.url)); + using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url)); await Cleanup(client); var createContainerParam = new PrmContainerCreate( - new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1)), [new("testKey", "testValue")])); + new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), + PrmWait.DefaultParams, + xheaders: ["testKey", "testValue"]); - var createdContainer = await client.CreateContainerAsync(createContainerParam); + var createdContainer = await client.CreateContainerAsync(createContainerParam, default); - var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer)); + var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer), default); Assert.NotNull(container); var bytes = new byte[256]; @@ -405,20 +401,16 @@ public class SmokeClientTests : SmokeTestsBase bytes[i] = (byte)i; } - var param = new PrmObjectPut - { - Header = new FrostFsObjectHeader( - containerId: createdContainer, - type: FrostFsObjectType.Regular), - Payload = new MemoryStream(bytes), - ClientCut = false - }; + var param = new PrmObjectPut( + new FrostFsObjectHeader(containerId: createdContainer, type: FrostFsObjectType.Regular), + payload: new MemoryStream(bytes), + clientCut: false); - var objectId = await client.PutObjectAsync(param); + var objectId = await client.PutObjectAsync(param, default); var rangeParam = new PrmRangeGet(createdContainer, objectId, new FrostFsRange(100, 64)); - var rangeReader = await client.GetRangeAsync(rangeParam); + var rangeReader = await client.GetRangeAsync(rangeParam, default); var downloadedBytes = new byte[rangeParam.Range.Length]; MemoryStream ms = new(downloadedBytes); @@ -433,7 +425,7 @@ public class SmokeClientTests : SmokeTestsBase await Cleanup(client); - await foreach (var _ in client.ListContainersAsync()) + await foreach (var _ in client.ListContainersAsync(default, default)) { Assert.Fail("Containers exist"); } @@ -442,16 +434,18 @@ public class SmokeClientTests : SmokeTestsBase [Fact] public async void RangeHashTest() { - using var client = FrostFSClient.GetSingleOwnerInstance(GetClientOptions(this.keyString, this.url)); + using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url)); await Cleanup(client); var createContainerParam = new PrmContainerCreate( - new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1)), [new("testKey", "testValue")])); + new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), + PrmWait.DefaultParams, + xheaders: ["testKey", "testValue"]); - var createdContainer = await client.CreateContainerAsync(createContainerParam); + var createdContainer = await client.CreateContainerAsync(createContainerParam, default); - var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer)); + var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer), default); Assert.NotNull(container); var bytes = new byte[256]; @@ -460,20 +454,18 @@ public class SmokeClientTests : SmokeTestsBase bytes[i] = (byte)i; } - var param = new PrmObjectPut - { - Header = new FrostFsObjectHeader( + var param = new PrmObjectPut( + new FrostFsObjectHeader( containerId: createdContainer, type: FrostFsObjectType.Regular), - Payload = new MemoryStream(bytes), - ClientCut = false - }; + payload: new MemoryStream(bytes), + clientCut: false); - var objectId = await client.PutObjectAsync(param); + var objectId = await client.PutObjectAsync(param, default); var rangeParam = new PrmRangeHashGet(createdContainer, objectId, [new FrostFsRange(100, 64)], bytes); - var hashes = await client.GetRangeHashAsync(rangeParam); + var hashes = await client.GetRangeHashAsync(rangeParam, default); foreach (var hash in hashes) { @@ -482,7 +474,7 @@ public class SmokeClientTests : SmokeTestsBase await Cleanup(client); - await foreach (var _ in client.ListContainersAsync()) + await foreach (var _ in client.ListContainersAsync(default, default)) { Assert.Fail("Containers exist"); } @@ -494,49 +486,48 @@ public class SmokeClientTests : SmokeTestsBase [InlineData(6 * 1024 * 1024 + 100)] public async void SimpleScenarioWithSessionTest(int objectSize) { - using var client = FrostFSClient.GetSingleOwnerInstance(GetClientOptions(this.keyString, this.url)); + using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url)); //Callback = new((CallStatistics cs) => Assert.True(cs.ElapsedMicroSeconds > 0)) - var token = await client.CreateSessionAsync(new PrmSessionCreate(int.MaxValue)); + var token = await client.CreateSessionAsync(new PrmSessionCreate(int.MaxValue), default); await Cleanup(client); - var ctx = new CallContext - { - Timeout = TimeSpan.FromSeconds(20), - - }; + var ctx = new CallContext(TimeSpan.FromSeconds(20)); var createContainerParam = new PrmContainerCreate( - new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), ctx); + new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), + PrmWait.DefaultParams); - var container = await client.CreateContainerAsync(createContainerParam); + var container = await client.CreateContainerAsync(createContainerParam, ctx); - var containerInfo = await client.GetContainerAsync(new PrmContainerGet(container, ctx)); + var containerInfo = await client.GetContainerAsync(new PrmContainerGet(container), ctx); Assert.NotNull(containerInfo); var bytes = GetRandomBytes(objectSize); - var param = new PrmObjectPut - { - Header = new FrostFsObjectHeader( + var param = new PrmObjectPut( + new FrostFsObjectHeader( containerId: container, type: FrostFsObjectType.Regular, [new FrostFsAttributePair("fileName", "test")]), - Payload = new MemoryStream(bytes), - ClientCut = false, - SessionToken = token - }; + payload: new MemoryStream(bytes), + clientCut: false, + sessionToken: token); - var objectId = await client.PutObjectAsync(param); + var objectId = await client.PutObjectAsync(param, default); var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test"); bool hasObject = false; - await foreach (var objId in client.SearchObjectsAsync(new PrmObjectSearch(container) { Filters = [filter], SessionToken = token })) + await foreach (var objId in client.SearchObjectsAsync( + new PrmObjectSearch(container, token, [], filter), default)) { hasObject = true; - var objHeader = await client.GetObjectHeadAsync(new PrmObjectHeadGet(container, objectId) { SessionToken = token }); + var res = await client.GetObjectHeadAsync(new PrmObjectHeadGet(container, objectId, false, token), default); + + var objHeader = res.HeaderInfo; + Assert.NotNull(objHeader); Assert.Equal((ulong)bytes.Length, objHeader.PayloadLength); Assert.NotNull(objHeader.Attributes); Assert.Single(objHeader.Attributes); @@ -546,7 +537,7 @@ public class SmokeClientTests : SmokeTestsBase Assert.True(hasObject); - var @object = await client.GetObjectAsync(new PrmObjectGet(container, objectId) { SessionToken = token }); + var @object = await client.GetObjectAsync(new PrmObjectGet(container, objectId, token), default); var downloadedBytes = new byte[@object.Header.PayloadLength]; MemoryStream ms = new(downloadedBytes); @@ -561,7 +552,7 @@ public class SmokeClientTests : SmokeTestsBase await Cleanup(client); - await foreach (var _ in client.ListContainersAsync()) + await foreach (var _ in client.ListContainersAsync(default, default)) { Assert.Fail("Containers exist"); } @@ -577,48 +568,48 @@ public class SmokeClientTests : SmokeTestsBase public async void ClientCutScenarioTest(int objectSize) { - var options = GetClientOptions(this.keyString, this.url); + var options = GetClientOptions(keyString, url); options.Value.Interceptors.Add(new CallbackInterceptor()); - using var client = FrostFSClient.GetSingleOwnerInstance(GetClientOptions(this.keyString, this.url)); + using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url)); await Cleanup(client); - var createContainerParam = new PrmContainerCreate(new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1)))) - { - WaitParams = lightWait - }; + var createContainerParam = new PrmContainerCreate( + new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), + lightWait); - var containerId = await client.CreateContainerAsync(createContainerParam); + var containerId = await client.CreateContainerAsync(createContainerParam, default); - var ctx = new CallContext { Timeout = TimeSpan.FromSeconds(10) }; + var ctx = new CallContext(TimeSpan.FromSeconds(10)); - var container = await client.GetContainerAsync(new PrmContainerGet(containerId, ctx)); + var container = await client.GetContainerAsync(new PrmContainerGet(containerId), ctx); Assert.NotNull(container); byte[] bytes = GetRandomBytes(objectSize); - var param = new PrmObjectPut - { - Header = new FrostFsObjectHeader( + var param = new PrmObjectPut( + new FrostFsObjectHeader( containerId: containerId, type: FrostFsObjectType.Regular, [new FrostFsAttributePair("fileName", "test")]), - Payload = new MemoryStream(bytes), - ClientCut = true - }; + payload: new MemoryStream(bytes), + clientCut: true); - var objectId = await client.PutObjectAsync(param); + var objectId = await client.PutObjectAsync(param, default); var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test"); bool hasObject = false; - await foreach (var objId in client.SearchObjectsAsync(new PrmObjectSearch(containerId, null, filter))) + await foreach (var objId in client.SearchObjectsAsync(new PrmObjectSearch(containerId, null, [], filter), default)) { hasObject = true; - var objHeader = await client.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId)); + var res = await client.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId), default); + + var objHeader = res.HeaderInfo; + Assert.NotNull(objHeader); Assert.Equal((ulong)bytes.Length, objHeader.PayloadLength); Assert.NotNull(objHeader.Attributes); Assert.Single(objHeader.Attributes); @@ -628,7 +619,7 @@ public class SmokeClientTests : SmokeTestsBase Assert.True(hasObject); - var @object = await client.GetObjectAsync(new PrmObjectGet(containerId, objectId)); + var @object = await client.GetObjectAsync(new PrmObjectGet(containerId, objectId), default); var downloadedBytes = new byte[@object.Header.PayloadLength]; MemoryStream ms = new(downloadedBytes); @@ -656,7 +647,7 @@ public class SmokeClientTests : SmokeTestsBase break; } - enumerator = client.ListContainersAsync().GetAsyncEnumerator(); + enumerator = client.ListContainersAsync(default, default).GetAsyncEnumerator(); await Task.Delay(500); } while (await enumerator!.MoveNextAsync()); @@ -668,8 +659,8 @@ public class SmokeClientTests : SmokeTestsBase bool callbackInvoked = false; bool intercepterInvoked = false; - var options = GetClientOptions(this.keyString, this.url); - options.Value.Callback = (CallStatistics cs) => + var options = GetClientOptions(keyString, url); + options.Value.Callback = (cs) => { callbackInvoked = true; Assert.True(cs.ElapsedMicroSeconds > 0); @@ -677,9 +668,9 @@ public class SmokeClientTests : SmokeTestsBase options.Value.Interceptors.Add(new CallbackInterceptor(s => intercepterInvoked = true)); - using var client = FrostFSClient.GetSingleOwnerInstance(options); + using var client = FrostFSClient.GetInstance(options); - var result = await client.GetNodeInfoAsync(new PrmNodeInfo()); + var result = await client.GetNodeInfoAsync(default); Assert.True(callbackInvoked); Assert.True(intercepterInvoked); @@ -712,9 +703,9 @@ public class SmokeClientTests : SmokeTestsBase static async Task Cleanup(IFrostFSClient client) { - await foreach (var cid in client.ListContainersAsync()) + await foreach (var cid in client.ListContainersAsync(default, default)) { - await client.DeleteContainerAsync(new PrmContainerDelete(cid) { WaitParams = lightWait }); + await client.DeleteContainerAsync(new PrmContainerDelete(cid, lightWait), default); } } } diff --git a/src/FrostFS.SDK.Tests/Smoke/PoolSmokeTests.cs b/src/FrostFS.SDK.Tests/Smoke/PoolSmokeTests.cs new file mode 100644 index 0000000..feaf838 --- /dev/null +++ b/src/FrostFS.SDK.Tests/Smoke/PoolSmokeTests.cs @@ -0,0 +1,585 @@ +using System.Diagnostics.CodeAnalysis; +using System.Security.Cryptography; + +using FrostFS.SDK.Client; +using FrostFS.SDK.Cryptography; + +using Microsoft.Extensions.Options; + +namespace FrostFS.SDK.Tests.Smoke; + +[SuppressMessage("Reliability", "CA2007:Consider calling ConfigureAwait on the awaited task", Justification = "Default Value is correct for tests")] +[SuppressMessage("Security", "CA5394:Do not use insecure randomness", Justification = "No secure purpose")] +public class PoolSmokeTests : SmokeTestsBase +{ + private static readonly PrmWait lightWait = new(100, 1); + + private InitParameters GetDefaultParams() + { + return new InitParameters + { + Key = keyString.LoadWif(), + + NodeParams = [new(1, url, 100.0f)], + ClientBuilder = null, + GracefulCloseOnSwitchTimeout = 30_000_000, + Logger = null + }; + } + + [Fact] + public async void NetworkMapTest() + { + var options = GetDefaultParams(); + + using var pool = new Pool(options); + + var error = await pool.Dial(new CallContext(TimeSpan.Zero)); + + Assert.Null(error); + + var result = await pool.GetNetmapSnapshotAsync(default); + + Assert.True(result.Epoch > 0); + Assert.Single(result.NodeInfoCollection); + + var item = result.NodeInfoCollection[0]; + Assert.Equal(2, item.Version.Major); + Assert.Equal(13, item.Version.Minor); + Assert.Equal(NodeState.Online, item.State); + Assert.True(item.PublicKey.Length > 0); + Assert.Single(item.Addresses); + Assert.Equal(9, item.Attributes.Count); + } + + [Fact] + public async void NodeInfoTest() + { + var options = GetDefaultParams(); + + using var pool = new Pool(options); + + var error = await pool.Dial(new CallContext(TimeSpan.Zero)); + + Assert.Null(error); + + var result = await pool.GetNodeInfoAsync(default); + + Assert.Equal(2, result.Version.Major); + Assert.Equal(13, result.Version.Minor); + Assert.Equal(NodeState.Online, result.State); + Assert.Equal(33, result.PublicKey.Length); + Assert.Single(result.Addresses); + Assert.Equal(9, result.Attributes.Count); + } + + [Fact] + public async void NodeInfoStatisticsTwoNodesTest() + { + var callbackText = string.Empty; + + var options = new InitParameters + { + Key = keyString.LoadWif(), + NodeParams = [ + new(1, url, 100.0f), + new(2, url.Replace('0', '1'), 100.0f) + ], + ClientBuilder = null, + GracefulCloseOnSwitchTimeout = 30_000_000, + Logger = null, + Callback = (cs) => callbackText = $"{cs.MethodName} took {cs.ElapsedMicroSeconds} microseconds" + }; + + using var pool = new Pool(options); + + var ctx = new CallContext(TimeSpan.Zero); + + var error = await pool.Dial(ctx).ConfigureAwait(true); + + Assert.Null(error); + + using var client = FrostFSClient.GetInstance(GetSingleOwnerOptions(keyString, url)); + + var result = await client.GetNodeInfoAsync(default); + + var statistics = pool.Statistic(); + + Assert.False(string.IsNullOrEmpty(callbackText)); + Assert.Contains(" took ", callbackText, StringComparison.Ordinal); + } + + [Fact] + public async void NodeInfoStatisticsTest() + { + var options = GetDefaultParams(); + + var callbackText = string.Empty; + options.Callback = (cs) => callbackText = $"{cs.MethodName} took {cs.ElapsedMicroSeconds} microseconds"; + + using var pool = new Pool(options); + + var ctx = new CallContext(TimeSpan.Zero); + + var error = await pool.Dial(ctx).ConfigureAwait(true); + + Assert.Null(error); + + using var client = FrostFSClient.GetInstance(GetSingleOwnerOptions(keyString, url)); + + var result = await client.GetNodeInfoAsync(default); + + Assert.False(string.IsNullOrEmpty(callbackText)); + Assert.Contains(" took ", callbackText, StringComparison.Ordinal); + } + + [Fact] + public async void GetSessionTest() + { + var options = GetDefaultParams(); + + using var pool = new Pool(options); + + var error = await pool.Dial(new CallContext(TimeSpan.Zero)).ConfigureAwait(true); + + Assert.Null(error); + + var prm = new PrmSessionCreate(100); + + var token = await pool.CreateSessionAsync(prm, default).ConfigureAwait(true); + + var ownerHash = Base58.Decode(OwnerId!.Value); + + Assert.NotNull(token); + Assert.NotEqual(Guid.Empty, token.Id); + Assert.Equal(33, token.SessionKey.Length); + } + + [Fact] + public async void CreateObjectWithSessionToken() + { + var options = GetDefaultParams(); + + using var pool = new Pool(options); + + var error = await pool.Dial(new CallContext(TimeSpan.Zero)).ConfigureAwait(true); + + Assert.Null(error); + + await Cleanup(pool); + + var token = await pool.CreateSessionAsync(new PrmSessionCreate(int.MaxValue), default); + + var createContainerParam = new PrmContainerCreate( + new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), + PrmWait.DefaultParams, + xheaders: ["key1", "value1"]); + + var containerId = await pool.CreateContainerAsync(createContainerParam, default); + + var bytes = GetRandomBytes(1024); + + var param = new PrmObjectPut( + new FrostFsObjectHeader( + containerId: containerId, + type: FrostFsObjectType.Regular, + [new FrostFsAttributePair("fileName", "test")]), + payload: new MemoryStream(bytes), + clientCut: false, + sessionToken: token); + + var objectId = await pool.PutObjectAsync(param, default).ConfigureAwait(true); + + var @object = await pool.GetObjectAsync(new PrmObjectGet(containerId, objectId), default); + + var downloadedBytes = new byte[@object.Header.PayloadLength]; + MemoryStream ms = new(downloadedBytes); + + ReadOnlyMemory? chunk = null; + while ((chunk = await @object.ObjectReader!.ReadChunk()) != null) + { + ms.Write(chunk.Value.Span); + } + + Assert.Equal(SHA256.HashData(bytes), SHA256.HashData(downloadedBytes)); + + await Cleanup(pool); + } + + [Fact] + public async void FilterTest() + { + var options = GetDefaultParams(); + + using var pool = new Pool(options); + + var error = await pool.Dial(new CallContext(TimeSpan.Zero)).ConfigureAwait(true); + + Assert.Null(error); + + await Cleanup(pool); + + var createContainerParam = new PrmContainerCreate( + new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), + lightWait); + + var containerId = await pool.CreateContainerAsync(createContainerParam, default); + + var bytes = new byte[] { 1, 2, 3 }; + + var ParentHeader = new FrostFsObjectHeader( + containerId: containerId, + type: FrostFsObjectType.Regular) + { + PayloadLength = 3 + }; + + var param = new PrmObjectPut( + new FrostFsObjectHeader( + containerId: containerId, + type: FrostFsObjectType.Regular, + [new FrostFsAttributePair("fileName", "test")], + new FrostFsSplit()), + payload: new MemoryStream(bytes), + clientCut: false); + + var objectId = await pool.PutObjectAsync(param, default); + + var head = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId), default); + + var ecdsaKey = keyString.LoadWif(); + + var networkInfo = await pool.GetNetmapSnapshotAsync(default); + + await CheckFilter(pool, containerId, new FilterByContainerId(FrostFsMatchType.Equals, containerId)); + + await CheckFilter(pool, containerId, new FilterByOwnerId(FrostFsMatchType.Equals, FrostFsOwner.FromKey(ecdsaKey))); + + await CheckFilter(pool, containerId, new FilterBySplitId(FrostFsMatchType.Equals, param.Header!.Split!.SplitId)); + + await CheckFilter(pool, containerId, new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test")); + + await CheckFilter(pool, containerId, new FilterByObjectId(FrostFsMatchType.Equals, objectId)); + + await CheckFilter(pool, containerId, new FilterByVersion(FrostFsMatchType.Equals, networkInfo.NodeInfoCollection[0].Version)); + + await CheckFilter(pool, containerId, new FilterByEpoch(FrostFsMatchType.Equals, networkInfo.Epoch)); + + await CheckFilter(pool, containerId, new FilterByPayloadLength(FrostFsMatchType.Equals, 3)); + + var checkSum = CheckSum.CreateCheckSum(bytes); + + await CheckFilter(pool, containerId, new FilterByPayloadHash(FrostFsMatchType.Equals, checkSum)); + + await CheckFilter(pool, containerId, new FilterByPhysicallyStored()); + } + + private static async Task CheckFilter(Pool pool, FrostFsContainerId containerId, IObjectFilter filter) + { + var resultObjectsCount = 0; + + PrmObjectSearch searchParam = new(containerId, null, [], filter); + + await foreach (var objId in pool.SearchObjectsAsync(searchParam, default)) + { + resultObjectsCount++; + var objHeader = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objId), default); + } + + Assert.True(0 < resultObjectsCount, $"Filter for {filter.Key} doesn't work"); + } + + [Theory] + [InlineData(1)] + [InlineData(3 * 1024 * 1024)] // exactly one chunk size - 3MB + [InlineData(6 * 1024 * 1024 + 100)] + public async void SimpleScenarioTest(int objectSize) + { + bool callbackInvoked = false; + + var options = GetDefaultParams(); + + options.Callback = new((cs) => + { + callbackInvoked = true; + Assert.True(cs.ElapsedMicroSeconds > 0); + }); + + using var pool = new Pool(options); + + var error = await pool.Dial(new CallContext(TimeSpan.Zero)).ConfigureAwait(true); + + Assert.Null(error); + + await Cleanup(pool); + + var ctx = new CallContext(TimeSpan.Zero); + + var createContainerParam = new PrmContainerCreate( + new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), + PrmWait.DefaultParams, + xheaders: ["testKey", "testValue"]); + + var createdContainer = await pool.CreateContainerAsync(createContainerParam, ctx); + + var container = await pool.GetContainerAsync(new PrmContainerGet(createdContainer), default); + Assert.NotNull(container); + Assert.True(callbackInvoked); + + var bytes = GetRandomBytes(objectSize); + + var param = new PrmObjectPut( + new FrostFsObjectHeader( + containerId: createdContainer, + type: FrostFsObjectType.Regular, + [new FrostFsAttributePair("fileName", "test")]), + payload: new MemoryStream(bytes), + clientCut: false); + + var objectId = await pool.PutObjectAsync(param, default); + + var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test"); + + bool hasObject = false; + await foreach (var objId in pool.SearchObjectsAsync(new PrmObjectSearch(createdContainer, null, [], filter), default)) + { + hasObject = true; + + var res = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(createdContainer, objectId), default); + var objHeader = res.HeaderInfo; + Assert.NotNull(objHeader); + Assert.Equal((ulong)bytes.Length, objHeader.PayloadLength); + Assert.NotNull(objHeader.Attributes); + Assert.Single(objHeader.Attributes!); + Assert.Equal("fileName", objHeader.Attributes!.First().Key); + Assert.Equal("test", objHeader.Attributes!.First().Value); + } + + Assert.True(hasObject); + + var @object = await pool.GetObjectAsync(new PrmObjectGet(createdContainer, objectId), default); + + var downloadedBytes = new byte[@object.Header.PayloadLength]; + MemoryStream ms = new(downloadedBytes); + + ReadOnlyMemory? chunk = null; + while ((chunk = await @object.ObjectReader!.ReadChunk()) != null) + { + ms.Write(chunk.Value.Span); + } + + Assert.Equal(SHA256.HashData(bytes), SHA256.HashData(downloadedBytes)); + + await Cleanup(pool); + + await foreach (var _ in pool.ListContainersAsync(default, default)) + { + Assert.Fail("Containers exist"); + } + } + + [Theory] + [InlineData(1)] + [InlineData(3 * 1024 * 1024)] // exactly one chunk size - 3MB + [InlineData(6 * 1024 * 1024 + 100)] + public async void SimpleScenarioWithSessionTest(int objectSize) + { + var options = GetDefaultParams(); + + using var pool = new Pool(options); + options.Callback = new((cs) => Assert.True(cs.ElapsedMicroSeconds > 0)); + + var error = await pool.Dial(new CallContext(TimeSpan.Zero)).ConfigureAwait(true); + + Assert.Null(error); + + var token = await pool.CreateSessionAsync(new PrmSessionCreate(int.MaxValue), default); + + await Cleanup(pool); + + var ctx = new CallContext(TimeSpan.FromSeconds(20)); + + var createContainerParam = new PrmContainerCreate( + new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), + PrmWait.DefaultParams); + + var container = await pool.CreateContainerAsync(createContainerParam, ctx); + + var containerInfo = await pool.GetContainerAsync(new PrmContainerGet(container), ctx); + Assert.NotNull(containerInfo); + + var bytes = GetRandomBytes(objectSize); + + var param = new PrmObjectPut( + new FrostFsObjectHeader( + containerId: container, + type: FrostFsObjectType.Regular, + [new FrostFsAttributePair("fileName", "test")]), + payload: new MemoryStream(bytes), + clientCut: false, + sessionToken: token); + + var objectId = await pool.PutObjectAsync(param, new CallContext(TimeSpan.Zero)); + + var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test"); + + bool hasObject = false; + var objs = pool.SearchObjectsAsync(new PrmObjectSearch(container, token, [], filter), default); + await foreach (var objId in objs) + { + hasObject = true; + + var res = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(container, objectId, false, token), default); + + var objHeader = res.HeaderInfo; + Assert.NotNull(objHeader); + Assert.Equal((ulong)bytes.Length, objHeader.PayloadLength); + Assert.NotNull(objHeader.Attributes); + Assert.Single(objHeader.Attributes); + Assert.Equal("fileName", objHeader.Attributes.First().Key); + Assert.Equal("test", objHeader.Attributes.First().Value); + } + + Assert.True(hasObject); + + var @object = await pool.GetObjectAsync(new PrmObjectGet(container, objectId, token), default); + + var downloadedBytes = new byte[@object.Header.PayloadLength]; + MemoryStream ms = new(downloadedBytes); + + ReadOnlyMemory? chunk = null; + while ((chunk = await @object.ObjectReader!.ReadChunk()) != null) + { + ms.Write(chunk.Value.Span); + } + + Assert.Equal(SHA256.HashData(bytes), SHA256.HashData(downloadedBytes)); + + await Cleanup(pool); + + await foreach (var _ in pool.ListContainersAsync(default, default)) + { + Assert.Fail("Containers exist"); + } + } + + [Theory] + [InlineData(1)] + [InlineData(64 * 1024 * 1024)] // exactly 1 block size - 64MB + [InlineData(64 * 1024 * 1024 - 1)] + [InlineData(64 * 1024 * 1024 + 1)] + [InlineData(2 * 64 * 1024 * 1024 + 256)] + [InlineData(200)] + public async void ClientCutScenarioTest(int objectSize) + { + var options = GetDefaultParams(); + + using var pool = new Pool(options); + + var error = await pool.Dial(new CallContext(TimeSpan.Zero)).ConfigureAwait(true); + + Assert.Null(error); + + await Cleanup(pool); + + var createContainerParam = new PrmContainerCreate( + new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), + lightWait); + + var containerId = await pool.CreateContainerAsync(createContainerParam, default); + + var ctx = new CallContext(TimeSpan.FromSeconds(10)); + + // ctx.Interceptors.Add(new CallbackInterceptor()); + + var container = await pool.GetContainerAsync(new PrmContainerGet(containerId), ctx); + + Assert.NotNull(container); + + byte[] bytes = GetRandomBytes(objectSize); + + var param = new PrmObjectPut( + new FrostFsObjectHeader( + containerId: containerId, + type: FrostFsObjectType.Regular, + [new FrostFsAttributePair("fileName", "test")]), + payload: new MemoryStream(bytes), + clientCut: true); + + var objectId = await pool.PutObjectAsync(param, default); + + var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test"); + + bool hasObject = false; + await foreach (var objId in pool.SearchObjectsAsync(new PrmObjectSearch(containerId, null, [], filter), default)) + { + hasObject = true; + + var res = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId), default); + + var objHeader = res.HeaderInfo; + Assert.NotNull(objHeader); Assert.Equal((ulong)bytes.Length, objHeader.PayloadLength); + Assert.NotNull(objHeader.Attributes); + Assert.Single(objHeader.Attributes); + Assert.Equal("fileName", objHeader.Attributes[0].Key); + Assert.Equal("test", objHeader.Attributes[0].Value); + } + + Assert.True(hasObject); + + var @object = await pool.GetObjectAsync(new PrmObjectGet(containerId, objectId), default); + + var downloadedBytes = new byte[@object.Header.PayloadLength]; + MemoryStream ms = new(downloadedBytes); + + ReadOnlyMemory? chunk = null; + while ((chunk = await @object.ObjectReader!.ReadChunk()) != null) + { + ms.Write(chunk.Value.Span); + } + + Assert.Equal(SHA256.HashData(bytes), SHA256.HashData(downloadedBytes)); + + await CheckFilter(pool, containerId, new FilterByRootObject()); + + await Cleanup(pool); + + await foreach (var cid in pool.ListContainersAsync(default, default)) + { + Assert.Fail($"Container {cid.GetValue()} exist"); + } + } + + private static byte[] GetRandomBytes(int size) + { + Random rnd = new(); + var bytes = new byte[size]; + rnd.NextBytes(bytes); + return bytes; + } + + private static IOptions GetSingleOwnerOptions(string key, string url) + { + return Options.Create(new ClientSettings + { + Key = key, + Host = url + }); + } + + private static IOptions GetOptions(string url) + { + return Options.Create(new ClientSettings + { + Host = url + }); + } + + static async Task Cleanup(Pool pool) + { + await foreach (var cid in pool.ListContainersAsync(default, default)) + { + await pool.DeleteContainerAsync(new PrmContainerDelete(cid, lightWait), default).ConfigureAwait(true); + } + } +} diff --git a/src/FrostFS.SDK.Tests/Smoke/SmokeClientTests.cs b/src/FrostFS.SDK.Tests/Smoke/SmokeClientTests.cs new file mode 100644 index 0000000..9c3b21f --- /dev/null +++ b/src/FrostFS.SDK.Tests/Smoke/SmokeClientTests.cs @@ -0,0 +1,709 @@ +using System.Diagnostics.CodeAnalysis; +using System.Security.Cryptography; + +using FrostFS.SDK.Client; +using FrostFS.SDK.Client.Interfaces; +using FrostFS.SDK.Cryptography; +using FrostFS.SDK.SmokeTests; + +using Microsoft.Extensions.Options; + +namespace FrostFS.SDK.Tests.Smoke; + +[SuppressMessage("Reliability", "CA2007:Consider calling ConfigureAwait on the awaited task", Justification = "Default Value is correct for tests")] +[SuppressMessage("Security", "CA5394:Do not use insecure randomness", Justification = "No secure purpose")] +public class SmokeClientTests : SmokeTestsBase +{ + private static readonly PrmWait lightWait = new(100, 1); + + [Fact] + public async void AccountTest() + { + using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url)); + + var result = await client.GetBalanceAsync(default); + + Assert.NotNull(result); + Assert.True(result.Value == 0); + } + + [Fact] + public async void NodeInfoTest() + { + using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url)); + + var result = await client.GetNodeInfoAsync(default); + + Assert.Equal(2, result.Version.Major); + Assert.Equal(13, result.Version.Minor); + Assert.Equal(NodeState.Online, result.State); + Assert.Equal(33, result.PublicKey.Length); + Assert.Single(result.Addresses); + Assert.Equal(9, result.Attributes.Count); + } + + [Fact] + public async void NodeInfoStatisticsTest() + { + var options = GetClientOptions(keyString, url); + + var callbackContent = string.Empty; + options.Value.Callback = (cs) => callbackContent = $"{cs.MethodName} took {cs.ElapsedMicroSeconds} microseconds"; + + using var client = FrostFSClient.GetInstance(options); + + var result = await client.GetNodeInfoAsync(default); + + Assert.NotEmpty(callbackContent); + } + + [Fact] + public async void GetSessionTest() + { + using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url)); + + var token = await client.CreateSessionAsync(new(100), default); + + var ownerHash = Base58.Decode(OwnerId!.Value); + + Assert.NotNull(token); + Assert.NotEqual(Guid.Empty, token.Id); + Assert.Equal(33, token.SessionKey.Length); + } + + [Fact] + public async void CreateObjectWithSessionToken() + { + using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url)); + + await Cleanup(client); + + var token = await client.CreateSessionAsync(new PrmSessionCreate(int.MaxValue), default); + + var createContainerParam = new PrmContainerCreate( + new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), + PrmWait.DefaultParams, + xheaders: ["key1", "value1"]); + + var containerId = await client.CreateContainerAsync(createContainerParam, default); + + var bytes = GetRandomBytes(1024); + + var param = new PrmObjectPut( + new FrostFsObjectHeader( + containerId: containerId, + type: FrostFsObjectType.Regular, + [new FrostFsAttributePair("fileName", "test")]), + payload: new MemoryStream(bytes), + clientCut: false, + sessionToken: token); + + var objectId = await client.PutObjectAsync(param, default).ConfigureAwait(true); + + var @object = await client.GetObjectAsync(new PrmObjectGet(containerId, objectId), default) + .ConfigureAwait(true); + + var downloadedBytes = new byte[@object.Header.PayloadLength]; + MemoryStream ms = new(downloadedBytes); + + ReadOnlyMemory? chunk = null; + while ((chunk = await @object.ObjectReader!.ReadChunk().ConfigureAwait(true)) != null) + { + ms.Write(chunk.Value.Span); + } + + Assert.Equal(SHA256.HashData(bytes), SHA256.HashData(downloadedBytes)); + + await Cleanup(client).ConfigureAwait(true); + } + + [Fact] + public async void FilterTest() + { + using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url)); + + await Cleanup(client); + + var createContainerParam = new PrmContainerCreate( + new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), + lightWait); + + var containerId = await client.CreateContainerAsync(createContainerParam, default); + + var bytes = new byte[] { 1, 2, 3 }; + + var ParentHeader = new FrostFsObjectHeader( + containerId: containerId, + type: FrostFsObjectType.Regular) + { + PayloadLength = 3 + }; + + var param = new PrmObjectPut( + new FrostFsObjectHeader( + containerId: containerId, + type: FrostFsObjectType.Regular, + [new FrostFsAttributePair("fileName", "test")], + new FrostFsSplit()), + payload: new MemoryStream(bytes), + clientCut: false); + + var objectId = await client.PutObjectAsync(param, default); + + var head = await client.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId), default); + + var ecdsaKey = keyString.LoadWif(); + + var networkInfo = await client.GetNetmapSnapshotAsync(default); + + await CheckFilter(client, containerId, new FilterByContainerId(FrostFsMatchType.Equals, containerId)); + + await CheckFilter(client, containerId, new FilterByOwnerId(FrostFsMatchType.Equals, FrostFsOwner.FromKey(ecdsaKey))); + + await CheckFilter(client, containerId, new FilterBySplitId(FrostFsMatchType.Equals, param.Header!.Split!.SplitId)); + + await CheckFilter(client, containerId, new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test")); + + await CheckFilter(client, containerId, new FilterByObjectId(FrostFsMatchType.Equals, objectId)); + + await CheckFilter(client, containerId, new FilterByVersion(FrostFsMatchType.Equals, networkInfo.NodeInfoCollection[0].Version)); + + await CheckFilter(client, containerId, new FilterByEpoch(FrostFsMatchType.Equals, networkInfo.Epoch)); + + await CheckFilter(client, containerId, new FilterByPayloadLength(FrostFsMatchType.Equals, 3)); + + var checkSum = CheckSum.CreateCheckSum(bytes); + + await CheckFilter(client, containerId, new FilterByPayloadHash(FrostFsMatchType.Equals, checkSum)); + + await CheckFilter(client, containerId, new FilterByPhysicallyStored()); + } + + private static async Task CheckFilter(IFrostFSClient client, FrostFsContainerId containerId, IObjectFilter filter) + { + var resultObjectsCount = 0; + + PrmObjectSearch searchParam = new(containerId, null, [], filter); + + await foreach (var objId in client.SearchObjectsAsync(searchParam, default)) + { + resultObjectsCount++; + var objHeader = await client.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objId), default); + } + + Assert.True(0 < resultObjectsCount, $"Filter for {filter.Key} doesn't work"); + } + + [Theory] + [InlineData(1)] + [InlineData(3 * 1024 * 1024)] // exactly one chunk size - 3MB + [InlineData(6 * 1024 * 1024 + 100)] + public async void SimpleScenarioTest(int objectSize) + { + bool callbackInvoked = false; + + var options = GetClientOptions(keyString, url); + + options.Value.Callback = new((cs) => + { + callbackInvoked = true; + Assert.True(cs.ElapsedMicroSeconds > 0); + }); + + using var client = FrostFSClient.GetInstance(options); + + await Cleanup(client); + + var ctx = new CallContext(TimeSpan.FromSeconds(20)); + + var createContainerParam = new PrmContainerCreate( + new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), + PrmWait.DefaultParams, + xheaders: ["testKey", "testValue"]); + + var createdContainer = await client.CreateContainerAsync(createContainerParam, ctx); + + var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer), default); + Assert.NotNull(container); + Assert.True(callbackInvoked); + + var bytes = GetRandomBytes(objectSize); + + var param = new PrmObjectPut( + new FrostFsObjectHeader( + containerId: createdContainer, + type: FrostFsObjectType.Regular, + [new FrostFsAttributePair("fileName", "test")]), + payload: new MemoryStream(bytes), + clientCut: false); + + var objectId = await client.PutObjectAsync(param, default); + + var filter1 = new FilterByOwnerId(FrostFsMatchType.Equals, OwnerId!); + await foreach (var objId in client.SearchObjectsAsync(new PrmObjectSearch(createdContainer, null, [], filter1), default)) + { + var objHeader = await client.GetObjectHeadAsync(new PrmObjectHeadGet(createdContainer, objectId, false), default); + + var objHeader1 = await client.GetObjectHeadAsync(new PrmObjectHeadGet(createdContainer, objectId, true), default); + + } + + var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test"); + + bool hasObject = false; + await foreach (var objId in client.SearchObjectsAsync(new PrmObjectSearch(createdContainer, null, [], filter), default)) + { + hasObject = true; + + var res = await client.GetObjectHeadAsync(new PrmObjectHeadGet(createdContainer, objectId), default); + + var objHeader = res.HeaderInfo; + Assert.NotNull(objHeader); + Assert.Equal((ulong)bytes.Length, objHeader.PayloadLength); + Assert.NotNull(objHeader.Attributes); + Assert.Single(objHeader.Attributes); + Assert.Equal("fileName", objHeader.Attributes.First().Key); + Assert.Equal("test", objHeader.Attributes.First().Value); + } + + Assert.True(hasObject); + + var @object = await client.GetObjectAsync(new PrmObjectGet(createdContainer, objectId), default); + + var downloadedBytes = new byte[@object.Header.PayloadLength]; + MemoryStream ms = new(downloadedBytes); + + ReadOnlyMemory? chunk = null; + while ((chunk = await @object.ObjectReader!.ReadChunk()) != null) + { + ms.Write(chunk.Value.Span); + } + + Assert.Equal(SHA256.HashData(bytes), SHA256.HashData(downloadedBytes)); + + await Cleanup(client); + + await foreach (var _ in client.ListContainersAsync(default, default)) + { + Assert.Fail("Containers exist"); + } + } + + [Fact] + public async void PatchTest() + { + using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url)); + + await Cleanup(client); + + var createContainerParam = new PrmContainerCreate( + new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), + PrmWait.DefaultParams, + xheaders: ["testKey", "testValue"]); + + var createdContainer = await client.CreateContainerAsync(createContainerParam, default); + + var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer), default); + Assert.NotNull(container); + + var bytes = new byte[1024]; + for (int i = 0; i < 1024; i++) + { + bytes[i] = 31; + } + + var param = new PrmObjectPut( + new FrostFsObjectHeader( + containerId: createdContainer, + type: FrostFsObjectType.Regular, + [new FrostFsAttributePair("fileName", "test")]), + payload: new MemoryStream(bytes), + clientCut: false); + + var objectId = await client.PutObjectAsync(param, default); + + var patch = new byte[16]; + for (int i = 0; i < 16; i++) + { + patch[i] = 32; + } + + var range = new FrostFsRange(8, (ulong)patch.Length); + + var patchParams = new PrmObjectPatch( + new FrostFsAddress(createdContainer, objectId), + payload: new MemoryStream(patch), + maxChunkLength: 32, + range: range); + + var newIbjId = await client.PatchObjectAsync(patchParams, default); + + var @object = await client.GetObjectAsync(new PrmObjectGet(createdContainer, newIbjId), default); + + var downloadedBytes = new byte[@object.Header.PayloadLength]; + MemoryStream ms = new(downloadedBytes); + + ReadOnlyMemory? chunk = null; + while ((chunk = await @object.ObjectReader!.ReadChunk()) != null) + { + ms.Write(chunk.Value.Span); + } + + for (int i = 0; i < (int)range.Offset; i++) + Assert.Equal(downloadedBytes[i], bytes[i]); + + var rangeEnd = range.Offset + range.Length; + + for (int i = (int)range.Offset; i < (int)rangeEnd; i++) + Assert.Equal(downloadedBytes[i], patch[i - (int)range.Offset]); + + for (int i = (int)rangeEnd; i < bytes.Length; i++) + Assert.Equal(downloadedBytes[i], bytes[i]); + + await Cleanup(client); + + await foreach (var _ in client.ListContainersAsync(default, default)) + { + Assert.Fail("Containers exist"); + } + } + + [Fact] + public async void RangeTest() + { + using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url)); + + await Cleanup(client); + + var createContainerParam = new PrmContainerCreate( + new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), + PrmWait.DefaultParams, + xheaders: ["testKey", "testValue"]); + + var createdContainer = await client.CreateContainerAsync(createContainerParam, default); + + var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer), default); + Assert.NotNull(container); + + var bytes = new byte[256]; + for (int i = 0; i < 256; i++) + { + bytes[i] = (byte)i; + } + + var param = new PrmObjectPut( + new FrostFsObjectHeader( + containerId: createdContainer, + type: FrostFsObjectType.Regular), + payload: new MemoryStream(bytes), + clientCut: false); + + var objectId = await client.PutObjectAsync(param, default); + + var rangeParam = new PrmRangeGet(createdContainer, objectId, new FrostFsRange(100, 64)); + + var rangeReader = await client.GetRangeAsync(rangeParam, default); + + var downloadedBytes = new byte[rangeParam.Range.Length]; + MemoryStream ms = new(downloadedBytes); + + ReadOnlyMemory? chunk = null; + while ((chunk = await rangeReader!.ReadChunk()) != null) + { + ms.Write(chunk.Value.Span); + } + + Assert.Equal(SHA256.HashData(bytes.AsSpan().Slice(100, 64)), SHA256.HashData(downloadedBytes)); + + await Cleanup(client); + + await foreach (var _ in client.ListContainersAsync(default, default)) + { + Assert.Fail("Containers exist"); + } + } + + [Fact] + public async void RangeHashTest() + { + using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url)); + + await Cleanup(client); + + var createContainerParam = new PrmContainerCreate( + new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), + PrmWait.DefaultParams, + xheaders: ["testKey", "testValue"]); + + var createdContainer = await client.CreateContainerAsync(createContainerParam, default); + + var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer), default); + Assert.NotNull(container); + + var bytes = new byte[256]; + for (int i = 0; i < 256; i++) + { + bytes[i] = (byte)i; + } + + var param = new PrmObjectPut( + new FrostFsObjectHeader( + containerId: createdContainer, + type: FrostFsObjectType.Regular), + payload: new MemoryStream(bytes), + clientCut: false); + + var objectId = await client.PutObjectAsync(param, default); + + var rangeParam = new PrmRangeHashGet(createdContainer, objectId, [new FrostFsRange(100, 64)], bytes); + + var hashes = await client.GetRangeHashAsync(rangeParam, default); + + foreach (var hash in hashes) + { + var x = hash[..32].ToArray(); + } + + await Cleanup(client); + + await foreach (var _ in client.ListContainersAsync(default, default)) + { + Assert.Fail("Containers exist"); + } + } + + [Theory] + [InlineData(1)] + [InlineData(3 * 1024 * 1024)] // exactly one chunk size - 3MB + [InlineData(6 * 1024 * 1024 + 100)] + public async void SimpleScenarioWithSessionTest(int objectSize) + { + using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url)); + //Callback = new((CallStatistics cs) => Assert.True(cs.ElapsedMicroSeconds > 0)) + var token = await client.CreateSessionAsync(new PrmSessionCreate(int.MaxValue), default); + + await Cleanup(client); + + var ctx = new CallContext(TimeSpan.FromSeconds(20)); + + var createContainerParam = new PrmContainerCreate( + new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), + PrmWait.DefaultParams); + + var container = await client.CreateContainerAsync(createContainerParam, ctx); + + var containerInfo = await client.GetContainerAsync(new PrmContainerGet(container), ctx); + Assert.NotNull(containerInfo); + + var bytes = GetRandomBytes(objectSize); + + var param = new PrmObjectPut( + new FrostFsObjectHeader( + containerId: container, + type: FrostFsObjectType.Regular, + [new FrostFsAttributePair("fileName", "test")]), + payload: new MemoryStream(bytes), + clientCut: false, + sessionToken: token); + + var objectId = await client.PutObjectAsync(param, default); + + var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test"); + + bool hasObject = false; + await foreach (var objId in client.SearchObjectsAsync(new PrmObjectSearch(container, token, [], filter), default)) + { + hasObject = true; + + var res = await client.GetObjectHeadAsync(new PrmObjectHeadGet(container, objectId, false, token), default); + + var objHeader = res.HeaderInfo; + Assert.NotNull(objHeader); + Assert.Equal((ulong)bytes.Length, objHeader.PayloadLength); + Assert.NotNull(objHeader.Attributes); + Assert.Single(objHeader.Attributes); + Assert.Equal("fileName", objHeader.Attributes.First().Key); + Assert.Equal("test", objHeader.Attributes.First().Value); + } + + Assert.True(hasObject); + + var @object = await client.GetObjectAsync(new PrmObjectGet(container, objectId, token), default); + + var downloadedBytes = new byte[@object.Header.PayloadLength]; + MemoryStream ms = new(downloadedBytes); + + ReadOnlyMemory? chunk = null; + while ((chunk = await @object.ObjectReader!.ReadChunk()) != null) + { + ms.Write(chunk.Value.Span); + } + + Assert.Equal(SHA256.HashData(bytes), SHA256.HashData(downloadedBytes)); + + await Cleanup(client); + + await foreach (var _ in client.ListContainersAsync(default, default)) + { + Assert.Fail("Containers exist"); + } + } + + [Theory] + [InlineData(1)] + [InlineData(64 * 1024 * 1024)] // exactly 1 block size - 64MB + [InlineData(64 * 1024 * 1024 - 1)] + [InlineData(64 * 1024 * 1024 + 1)] + [InlineData(2 * 64 * 1024 * 1024 + 256)] + [InlineData(200)] + public async void ClientCutScenarioTest(int objectSize) + { + + var options = GetClientOptions(keyString, url); + options.Value.Interceptors.Add(new CallbackInterceptor()); + + using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url)); + + await Cleanup(client); + + var createContainerParam = new PrmContainerCreate( + new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), + lightWait); + + var containerId = await client.CreateContainerAsync(createContainerParam, default); + + var ctx = new CallContext(TimeSpan.FromSeconds(10)); + + var container = await client.GetContainerAsync(new PrmContainerGet(containerId), ctx); + + Assert.NotNull(container); + + byte[] bytes = GetRandomBytes(objectSize); + + var param = new PrmObjectPut( + new FrostFsObjectHeader( + containerId: containerId, + type: FrostFsObjectType.Regular, + [new FrostFsAttributePair("fileName", "test")]), + payload: new MemoryStream(bytes), + clientCut: true); + + var objectId = await client.PutObjectAsync(param, default); + + // var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test"); + + //bool hasObject = false; + //await foreach (var objId in client.SearchObjectsAsync(new PrmObjectSearch(containerId, null, [], filter), default)) + //{ + // hasObject = true; + + // var objHeader = await client.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId), default); + // Assert.Equal((ulong)bytes.Length, objHeader.PayloadLength); + // Assert.NotNull(objHeader.Attributes); + // Assert.Single(objHeader.Attributes); + // Assert.Equal("fileName", objHeader.Attributes[0].Key); + // Assert.Equal("test", objHeader.Attributes[0].Value); + //} + + //Assert.True(hasObject); + + + var filter1 = new FilterByOwnerId(FrostFsMatchType.Equals, OwnerId!); + await foreach (var objId in client.SearchObjectsAsync(new PrmObjectSearch(containerId, null, [], filter1), default)) + { + var objHeader = await client.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId, false), default); + + var objHeader1 = await client.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId, true), default); + + } + + var @object = await client.GetObjectAsync(new PrmObjectGet(containerId, objectId), default); + + var downloadedBytes = new byte[@object.Header.PayloadLength]; + MemoryStream ms = new(downloadedBytes); + + ReadOnlyMemory? chunk = null; + while ((chunk = await @object.ObjectReader!.ReadChunk()) != null) + { + ms.Write(chunk.Value.Span); + } + + Assert.Equal(SHA256.HashData(bytes), SHA256.HashData(downloadedBytes)); + + await CheckFilter(client, containerId, new FilterByRootObject()); + + await Cleanup(client); + + var deadline = DateTime.UtcNow.Add(TimeSpan.FromSeconds(5)); + + IAsyncEnumerator? enumerator = null; + do + { + if (deadline <= DateTime.UtcNow) + { + Assert.Fail("Containers exist"); + break; + } + + enumerator = client.ListContainersAsync(default, default).GetAsyncEnumerator(); + await Task.Delay(500); + } + while (await enumerator!.MoveNextAsync()); + } + + [Fact] + public async void NodeInfoCallbackAndInterceptorTest() + { + bool callbackInvoked = false; + bool intercepterInvoked = false; + + var options = GetClientOptions(keyString, url); + options.Value.Callback = (cs) => + { + callbackInvoked = true; + Assert.True(cs.ElapsedMicroSeconds > 0); + }; + + options.Value.Interceptors.Add(new CallbackInterceptor(s => intercepterInvoked = true)); + + using var client = FrostFSClient.GetInstance(options); + + var result = await client.GetNodeInfoAsync(default); + + Assert.True(callbackInvoked); + Assert.True(intercepterInvoked); + + Assert.Equal(2, result.Version.Major); + Assert.Equal(13, result.Version.Minor); + Assert.Equal(NodeState.Online, result.State); + Assert.Equal(33, result.PublicKey.Length); + Assert.Single(result.Addresses); + Assert.Equal(9, result.Attributes.Count); + } + + private static byte[] GetRandomBytes(int size) + { + Random rnd = new(); + var bytes = new byte[size]; + rnd.NextBytes(bytes); + return bytes; + } + + private static IOptions GetClientOptions(string key, string url) + { + return Options.Create(new ClientSettings + { + Key = key, + Host = url + }); + } + + + static async Task Cleanup(IFrostFSClient client) + { + await foreach (var cid in client.ListContainersAsync(default, default)) + { + await client.DeleteContainerAsync(new PrmContainerDelete(cid, lightWait), default); + } + } +} diff --git a/src/FrostFS.SDK.Tests/SmokeTestsBase.cs b/src/FrostFS.SDK.Tests/Smoke/SmokeTestsBase.cs similarity index 94% rename from src/FrostFS.SDK.Tests/SmokeTestsBase.cs rename to src/FrostFS.SDK.Tests/Smoke/SmokeTestsBase.cs index b96997c..0b711df 100644 --- a/src/FrostFS.SDK.Tests/SmokeTestsBase.cs +++ b/src/FrostFS.SDK.Tests/Smoke/SmokeTestsBase.cs @@ -3,7 +3,7 @@ using FrostFS.SDK.Client; using FrostFS.SDK.Cryptography; -namespace FrostFS.SDK.SmokeTests; +namespace FrostFS.SDK.Tests.Smoke; public abstract class SmokeTestsBase { diff --git a/src/FrostFS.SDK.Tests/ContainerTest.cs b/src/FrostFS.SDK.Tests/Unit/ContainerTest.cs similarity index 89% rename from src/FrostFS.SDK.Tests/ContainerTest.cs rename to src/FrostFS.SDK.Tests/Unit/ContainerTest.cs index 0d12107..2088b4b 100644 --- a/src/FrostFS.SDK.Tests/ContainerTest.cs +++ b/src/FrostFS.SDK.Tests/Unit/ContainerTest.cs @@ -6,7 +6,7 @@ using FrostFS.SDK.Cryptography; using Google.Protobuf; -namespace FrostFS.SDK.Tests; +namespace FrostFS.SDK.Tests.Unit; [SuppressMessage("Reliability", "CA2007:Consider calling ConfigureAwait on the awaited task", Justification = "Default Value is correct for tests")] public class ContainerTest : ContainerTestsBase @@ -14,9 +14,9 @@ public class ContainerTest : ContainerTestsBase [Fact] public async void CreateContainerTest() { - var param = new PrmContainerCreate(new FrostFsContainerInfo(Mocker.PlacementPolicy)); + var param = new PrmContainerCreate(new FrostFsContainerInfo(Mocker.PlacementPolicy), PrmWait.DefaultParams); - var result = await GetClient().CreateContainerAsync(param); + var result = await GetClient().CreateContainerAsync(param, default); Assert.NotNull(result); Assert.NotNull(result.GetValue()); @@ -28,7 +28,7 @@ public class ContainerTest : ContainerTestsBase { var cid = new FrostFsContainerId(Base58.Encode(Mocker.ContainerGuid.ToBytes())); - var result = await GetClient().GetContainerAsync(new PrmContainerGet(cid)); + var result = await GetClient().GetContainerAsync(new PrmContainerGet(cid), default); Assert.NotNull(result); Assert.Equal(Mocker.ContainerGuid, result.Nonce); @@ -43,7 +43,7 @@ public class ContainerTest : ContainerTestsBase Mocker.ContainerIds.Add([0xbb]); Mocker.ContainerIds.Add([0xcc]); - var result = GetClient().ListContainersAsync(); + var result = GetClient().ListContainersAsync(default, default); Assert.NotNull(result); @@ -63,7 +63,7 @@ public class ContainerTest : ContainerTestsBase Mocker.ReturnContainerRemoved = true; var cid = new FrostFsContainerId(Base58.Encode(Mocker.ContainerGuid.ToBytes())); - await GetClient().DeleteContainerAsync(new PrmContainerDelete(cid)); + await GetClient().DeleteContainerAsync(new PrmContainerDelete(cid, PrmWait.DefaultParams), default); Assert.Single(Mocker.Requests); diff --git a/src/FrostFS.SDK.Tests/ContainerTestsBase.cs b/src/FrostFS.SDK.Tests/Unit/ContainerTestsBase.cs similarity index 78% rename from src/FrostFS.SDK.Tests/ContainerTestsBase.cs rename to src/FrostFS.SDK.Tests/Unit/ContainerTestsBase.cs index 3a0d396..80a70fe 100644 --- a/src/FrostFS.SDK.Tests/ContainerTestsBase.cs +++ b/src/FrostFS.SDK.Tests/Unit/ContainerTestsBase.cs @@ -2,7 +2,7 @@ using Microsoft.Extensions.Options; -namespace FrostFS.SDK.Tests; +namespace FrostFS.SDK.Tests.Unit; public abstract class ContainerTestsBase { @@ -19,7 +19,7 @@ public abstract class ContainerTestsBase Host = "http://localhost:8080" }); - Mocker = new ContainerMocker(this.key) + Mocker = new ContainerMocker(key) { PlacementPolicy = new FrostFsPlacementPolicy(true, new FrostFsReplica(1)), Version = new FrostFsVersion(2, 13), @@ -32,9 +32,9 @@ public abstract class ContainerTestsBase return Client.FrostFSClient.GetTestInstance( Settings, null, - new NetworkMocker(this.key).GetMock().Object, - new SessionMocker(this.key).GetMock().Object, + new NetworkMocker(key).GetMock().Object, + new SessionMocker(key).GetMock().Object, Mocker.GetMock().Object, - new ObjectMocker(this.key).GetMock().Object); + new ObjectMocker(key).GetMock().Object); } } diff --git a/src/FrostFS.SDK.Tests/NetworkTest.cs b/src/FrostFS.SDK.Tests/Unit/NetworkTest.cs similarity index 81% rename from src/FrostFS.SDK.Tests/NetworkTest.cs rename to src/FrostFS.SDK.Tests/Unit/NetworkTest.cs index 9e83bb0..b1146f7 100644 --- a/src/FrostFS.SDK.Tests/NetworkTest.cs +++ b/src/FrostFS.SDK.Tests/Unit/NetworkTest.cs @@ -5,7 +5,7 @@ using FrostFS.SDK.Client; using Google.Protobuf; -namespace FrostFS.SDK.Tests; +namespace FrostFS.SDK.Tests.Unit; [SuppressMessage("Reliability", "CA2007:Consider calling ConfigureAwait on the awaited task", Justification = "Default Value is correct for tests")] public class NetworkTest : NetworkTestsBase @@ -28,17 +28,13 @@ public class NetworkTest : NetworkTestsBase Mocker.Parameters.Add("HomomorphicHashingDisabled", [1]); Mocker.Parameters.Add("MaintenanceModeAllowed", [1]); - var param = useContext ? - new PrmNetworkSettings(new CallContext - { - CancellationToken = Mocker.CancellationTokenSource.Token, - Timeout = TimeSpan.FromSeconds(20) - }) - : new PrmNetworkSettings(); + var ctx = useContext + ? new CallContext(TimeSpan.FromSeconds(20), Mocker.CancellationTokenSource.Token) + : default; var validTimeoutFrom = DateTime.UtcNow.AddSeconds(20); - var result = await GetClient(DefaultSettings).GetNetworkSettingsAsync(param); + var result = await GetClient(DefaultSettings).GetNetworkSettingsAsync(ctx); var validTimeoutTo = DateTime.UtcNow.AddSeconds(20); @@ -110,28 +106,13 @@ public class NetworkTest : NetworkTestsBase Mocker.NetmapSnapshotResponse = new NetmapSnapshotResponse { Body = body }; - PrmNetmapSnapshot param = new(); - - if (useContext) - { - var ctx = new CallContext - { - CancellationToken = Mocker.CancellationTokenSource.Token, - Timeout = TimeSpan.FromSeconds(20) - }; - - param = new(ctx); - param.XHeaders.Add("headerKey1", "headerValue1"); - - } - else - { - param = new(); - } + var ctx = useContext + ? new CallContext(TimeSpan.FromSeconds(20), Mocker.CancellationTokenSource.Token) + : default; var validTimeoutFrom = DateTime.UtcNow.AddSeconds(20); - var result = await GetClient(DefaultSettings).GetNetmapSnapshotAsync(param); + var result = await GetClient(DefaultSettings).GetNetmapSnapshotAsync(ctx); var validTimeoutTo = DateTime.UtcNow.AddSeconds(20); @@ -166,13 +147,10 @@ public class NetworkTest : NetworkTestsBase if (useContext) { Assert.NotNull(Mocker.NetmapSnapshotRequest); - Assert.Single(Mocker.NetmapSnapshotRequest.MetaHeader.XHeaders); - Assert.Equal(param.XHeaders.Keys[0], Mocker.NetmapSnapshotRequest.MetaHeader.XHeaders.First().Key); - Assert.Equal(param.XHeaders[param.XHeaders.Keys[0]], Mocker.NetmapSnapshotRequest.MetaHeader.XHeaders.First().Value); + Assert.Empty(Mocker.NetmapSnapshotRequest.MetaHeader.XHeaders); Assert.Equal(Mocker.CancellationTokenSource.Token, Mocker.CancellationToken); Assert.NotNull(Mocker.DateTime); - Assert.True(Mocker.DateTime.Value >= validTimeoutFrom); Assert.True(Mocker.DateTime.Value <= validTimeoutTo); } @@ -206,28 +184,13 @@ public class NetworkTest : NetworkTestsBase Mocker.NodeInfoResponse = new LocalNodeInfoResponse { Body = body }; - PrmNodeInfo param; - - if (useContext) - { - var ctx = new CallContext - { - CancellationToken = Mocker.CancellationTokenSource.Token, - Timeout = TimeSpan.FromSeconds(20) - }; - - param = new(ctx); - param.XHeaders.Add("headerKey1", "headerValue1"); - - } - else - { - param = new(); - } + var ctx = useContext + ? new CallContext(TimeSpan.FromSeconds(20), Mocker.CancellationTokenSource.Token) + : default; var validTimeoutFrom = DateTime.UtcNow.AddSeconds(20); - var result = await GetClient(DefaultSettings).GetNodeInfoAsync(param); + var result = await GetClient(DefaultSettings).GetNodeInfoAsync(ctx); var validTimeoutTo = DateTime.UtcNow.AddSeconds(20); @@ -246,10 +209,7 @@ public class NetworkTest : NetworkTestsBase Assert.NotNull(Mocker.LocalNodeInfoRequest); if (useContext) { - Assert.Single(Mocker.LocalNodeInfoRequest.MetaHeader.XHeaders); - Assert.Equal(param.XHeaders.Keys[0], Mocker.LocalNodeInfoRequest.MetaHeader.XHeaders.First().Key); - Assert.Equal(param.XHeaders[param.XHeaders.Keys[0]], Mocker.LocalNodeInfoRequest.MetaHeader.XHeaders.First().Value); - + Assert.Empty(Mocker.LocalNodeInfoRequest.MetaHeader.XHeaders); Assert.Equal(Mocker.CancellationTokenSource.Token, Mocker.CancellationToken); Assert.NotNull(Mocker.DateTime); diff --git a/src/FrostFS.SDK.Tests/NetworkTestsBase.cs b/src/FrostFS.SDK.Tests/Unit/NetworkTestsBase.cs similarity index 79% rename from src/FrostFS.SDK.Tests/NetworkTestsBase.cs rename to src/FrostFS.SDK.Tests/Unit/NetworkTestsBase.cs index 0cabab5..2bbfb9f 100644 --- a/src/FrostFS.SDK.Tests/NetworkTestsBase.cs +++ b/src/FrostFS.SDK.Tests/Unit/NetworkTestsBase.cs @@ -4,7 +4,7 @@ using FrostFS.SDK.Client.Interfaces; using Microsoft.Extensions.Options; -namespace FrostFS.SDK.Tests; +namespace FrostFS.SDK.Tests.Unit; [SuppressMessage("Reliability", "CA2007:Consider calling ConfigureAwait on the awaited task", Justification = "Default Value is correct for tests")] public abstract class NetworkTestsBase @@ -25,7 +25,7 @@ public abstract class NetworkTestsBase Host = "http://localhost:8080", }; - Mocker = new NetworkMocker(this.key); + Mocker = new NetworkMocker(key); } protected IFrostFSClient GetClient(ClientSettings settings) @@ -34,8 +34,8 @@ public abstract class NetworkTestsBase Options.Create(settings), null, Mocker.GetMock().Object, - new SessionMocker(this.key).GetMock().Object, - new ContainerMocker(this.key).GetMock().Object, - new ObjectMocker(this.key).GetMock().Object); + new SessionMocker(key).GetMock().Object, + new ContainerMocker(key).GetMock().Object, + new ObjectMocker(key).GetMock().Object); } } diff --git a/src/FrostFS.SDK.Tests/ObjectTest.cs b/src/FrostFS.SDK.Tests/Unit/ObjectTest.cs similarity index 76% rename from src/FrostFS.SDK.Tests/ObjectTest.cs rename to src/FrostFS.SDK.Tests/Unit/ObjectTest.cs index 5914605..8d837c5 100644 --- a/src/FrostFS.SDK.Tests/ObjectTest.cs +++ b/src/FrostFS.SDK.Tests/Unit/ObjectTest.cs @@ -9,34 +9,12 @@ using FrostFS.SDK.Client.Mappers.GRPC; using Google.Protobuf; -namespace FrostFS.SDK.Tests; +namespace FrostFS.SDK.Tests.Unit; [SuppressMessage("Reliability", "CA2007:Consider calling ConfigureAwait on the awaited task", Justification = "Default Value is correct for tests")] [SuppressMessage("Security", "CA5394:Do not use insecure randomness", Justification = "No secure purpose")] public class ObjectTest : ObjectTestsBase { - [Fact] - public async void GetObjectTest() - { - var client = GetClient(); - - var objectId = client.CalculateObjectId(Mocker.ObjectHeader!); - - var result = await client.GetObjectAsync(new PrmObjectGet(ContainerId, objectId)); - - Assert.NotNull(result); - - Assert.NotNull(Mocker.ObjectHeader); - - Assert.Equal(Mocker.ObjectHeader.ContainerId.GetValue(), result.Header.ContainerId.GetValue()); - Assert.Equal(Mocker.ObjectHeader.OwnerId!.Value, result.Header.OwnerId!.Value); - Assert.Equal(Mocker.ObjectHeader.PayloadLength, result.Header.PayloadLength); - Assert.NotNull(result.Header.Attributes); - Assert.Single(result.Header.Attributes); - Assert.Equal(Mocker.ObjectHeader.Attributes![0].Key, result.Header.Attributes[0].Key); - Assert.Equal(Mocker.ObjectHeader.Attributes![0].Value, result.Header.Attributes[0].Value); - } - [Fact] public async void PutObjectTest() { @@ -46,14 +24,12 @@ public class ObjectTest : ObjectTestsBase var bytes = new byte[1024]; rnd.NextBytes(bytes); - var param = new PrmObjectPut - { - Header = Mocker.ObjectHeader, - Payload = new MemoryStream(bytes), - ClientCut = false - }; + var param = new PrmObjectPut( + Mocker.ObjectHeader, + payload: new MemoryStream(bytes), + clientCut: false); - var result = await GetClient().PutObjectAsync(param); + var result = await GetClient().PutObjectAsync(param, default); var sentMessages = Mocker.ClientStreamWriter!.Messages; @@ -81,13 +57,11 @@ public class ObjectTest : ObjectTestsBase byte[] bytes = File.ReadAllBytes(@".\..\..\..\cat.jpg"); var fileLength = bytes.Length; - var param = new PrmObjectPut - { - Header = Mocker.ObjectHeader, - Payload = new MemoryStream(bytes), - BufferMaxSize = 1024, - ClientCut = true - }; + var param = new PrmObjectPut( + Mocker.ObjectHeader, + payload: new MemoryStream(bytes), + bufferMaxSize: 1024, + clientCut: true); Random rnd = new(); @@ -99,7 +73,7 @@ public class ObjectTest : ObjectTestsBase foreach (var objId in objIds) Mocker.ResultObjectIds!.Add(objId); - var result = await GetClient().PutObjectAsync(param); + var result = await GetClient().PutObjectAsync(param, default); var singleObjects = Mocker.PutSingleRequests.ToArray(); @@ -151,7 +125,7 @@ public class ObjectTest : ObjectTestsBase Assert.NotNull(header3.Split.ParentHeader); Assert.NotNull(header3.Split.ParentSignature); Assert.Equal(header2.Split.SplitId, header3.Split.SplitId); - Assert.Equal(bytes[((fileLength / blockSize) * blockSize)..fileLength], payload3); + Assert.Equal(bytes[(fileLength / blockSize * blockSize)..fileLength], payload3); Assert.True(header3.Attributes.Count == 0); //link object @@ -175,7 +149,7 @@ public class ObjectTest : ObjectTestsBase { Mocker.ObjectId = new ObjectID { Value = ByteString.CopyFrom(SHA256.HashData(Encoding.UTF8.GetBytes("test"))) }.ToModel(); - await GetClient().DeleteObjectAsync(new PrmObjectDelete(ContainerId, Mocker.ObjectId)); + await GetClient().DeleteObjectAsync(new PrmObjectDelete(ContainerId, Mocker.ObjectId), default); var request = Mocker.DeleteRequests.FirstOrDefault(); Assert.NotNull(request); @@ -188,30 +162,33 @@ public class ObjectTest : ObjectTestsBase { Mocker.ObjectId = new ObjectID { Value = ByteString.CopyFrom(SHA256.HashData(Encoding.UTF8.GetBytes("test"))) }.ToModel(); - var response = await GetClient().GetObjectHeadAsync(new PrmObjectHeadGet(ContainerId, Mocker.ObjectId)); + var res = await GetClient().GetObjectHeadAsync(new PrmObjectHeadGet(ContainerId, Mocker.ObjectId), default); + + var objHeader = res.HeaderInfo; + Assert.NotNull(objHeader); var request = Mocker.HeadRequests.FirstOrDefault(); Assert.NotNull(request); Assert.Equal(ContainerId.ToMessage(), request.Body.Address.ContainerId); Assert.Equal(Mocker.ObjectId.ToMessage(), request.Body.Address.ObjectId); - Assert.NotNull(response); - Assert.Equal(ContainerId.GetValue(), response.ContainerId.GetValue()); + Assert.NotNull(objHeader); + Assert.Equal(ContainerId.GetValue(), objHeader.ContainerId.GetValue()); - Assert.Equal(Mocker.ObjectHeader!.OwnerId!.Value, response.OwnerId!.Value); - Assert.Equal(Mocker.ObjectHeader!.Version!.ToString(), response.Version!.ToString()); + Assert.Equal(Mocker.ObjectHeader!.OwnerId!.Value, objHeader.OwnerId!.Value); + Assert.Equal(Mocker.ObjectHeader!.Version!.ToString(), objHeader.Version!.ToString()); - Assert.Equal(Mocker.HeadResponse!.PayloadLength, response.PayloadLength); + Assert.Equal(Mocker.HeadResponse!.PayloadLength, objHeader.PayloadLength); - Assert.Equal(FrostFsObjectType.Regular, response.ObjectType); + Assert.Equal(FrostFsObjectType.Regular, objHeader.ObjectType); - Assert.NotNull(response.Attributes); - Assert.Single(response.Attributes); + Assert.NotNull(objHeader.Attributes); + Assert.Single(objHeader.Attributes); - Assert.Equal(Mocker.HeadResponse.Attributes[0].Key, response.Attributes.First().Key); - Assert.Equal(Mocker.HeadResponse.Attributes[0].Value, response.Attributes.First().Value); + Assert.Equal(Mocker.HeadResponse.Attributes[0].Key, objHeader.Attributes.First().Key); + Assert.Equal(Mocker.HeadResponse.Attributes[0].Value, objHeader.Attributes.First().Value); - Assert.Null(response.Split); + Assert.Null(objHeader.Split); } [Fact] @@ -229,7 +206,7 @@ public class ObjectTest : ObjectTestsBase var param = new PrmRangeGet(ContainerId, Mocker.ObjectId, new FrostFsRange(100, (ulong)Mocker.RangeResponse.Length)); - var result = await GetClient().GetRangeAsync(param); + var result = await GetClient().GetRangeAsync(param, default); Assert.NotNull(Mocker.GetRangeRequest); @@ -271,7 +248,7 @@ public class ObjectTest : ObjectTestsBase var param = new PrmRangeHashGet(ContainerId, Mocker.ObjectId, [new FrostFsRange(100, len)], salt); - var result = await GetClient().GetRangeHashAsync(param); + var result = await GetClient().GetRangeHashAsync(param, default); Assert.NotNull(Mocker.GetRangeHashRequest); @@ -299,14 +276,13 @@ public class ObjectTest : ObjectTestsBase var range = new FrostFsRange(8, (ulong)patch.Length); - var param = new PrmObjectPatch(address) - { - Payload = new MemoryStream(patch), - MaxPayloadPatchChunkLength = 32, - Range = range - }; + var param = new PrmObjectPatch( + address, + payload: new MemoryStream(patch), + maxChunkLength: 32, + range: range); - var result = await GetClient().PatchObjectAsync(param); + var result = await GetClient().PatchObjectAsync(param, default); Assert.NotNull(result); diff --git a/src/FrostFS.SDK.Tests/ObjectTestsBase.cs b/src/FrostFS.SDK.Tests/Unit/ObjectTestsBase.cs similarity index 98% rename from src/FrostFS.SDK.Tests/ObjectTestsBase.cs rename to src/FrostFS.SDK.Tests/Unit/ObjectTestsBase.cs index 21289e4..ba8bb21 100644 --- a/src/FrostFS.SDK.Tests/ObjectTestsBase.cs +++ b/src/FrostFS.SDK.Tests/Unit/ObjectTestsBase.cs @@ -4,7 +4,7 @@ using FrostFS.SDK.Cryptography; using Microsoft.Extensions.Options; -namespace FrostFS.SDK.Tests; +namespace FrostFS.SDK.Tests.Unit; public abstract class ObjectTestsBase { diff --git a/src/FrostFS.SDK.Tests/SessionTests.cs b/src/FrostFS.SDK.Tests/Unit/SessionTests.cs similarity index 78% rename from src/FrostFS.SDK.Tests/SessionTests.cs rename to src/FrostFS.SDK.Tests/Unit/SessionTests.cs index 9e79b29..b2f1b78 100644 --- a/src/FrostFS.SDK.Tests/SessionTests.cs +++ b/src/FrostFS.SDK.Tests/Unit/SessionTests.cs @@ -4,7 +4,7 @@ using FrostFS.SDK.Client; using FrostFS.SDK.Client.Mappers.GRPC; using FrostFS.SDK.Cryptography; -namespace FrostFS.SDK.Tests; +namespace FrostFS.SDK.Tests.Unit; [SuppressMessage("Reliability", "CA2007:Consider calling ConfigureAwait on the awaited task", Justification = "Default Value is correct for tests")] public class SessionTest : SessionTestsBase @@ -17,26 +17,21 @@ public class SessionTest : SessionTestsBase var exp = 100u; PrmSessionCreate param; + CallContext ctx; if (useContext) { - var ctx = new CallContext - { - CancellationToken = Mocker.CancellationTokenSource.Token, - Timeout = TimeSpan.FromSeconds(20) - }; - - param = new PrmSessionCreate(exp, ctx); - - param.XHeaders.Add("headerKey1", "headerValue1"); + ctx = new CallContext(TimeSpan.FromSeconds(20), Mocker.CancellationTokenSource.Token); + param = new PrmSessionCreate(exp, ["headerKey1", "headerValue1"]); } else { + ctx = default; param = new PrmSessionCreate(exp); } var validTimeoutFrom = DateTime.UtcNow.AddSeconds(20); - var result = await GetClient().CreateSessionAsync(param); + var result = await GetClient().CreateSessionAsync(param, ctx); var validTimeoutTo = DateTime.UtcNow.AddSeconds(20); @@ -64,8 +59,8 @@ public class SessionTest : SessionTestsBase if (useContext) { Assert.Single(Mocker.CreateSessionRequest.MetaHeader.XHeaders); - Assert.Equal(param.XHeaders.Keys[0], Mocker.CreateSessionRequest.MetaHeader.XHeaders.First().Key); - Assert.Equal(param.XHeaders[param.XHeaders.Keys[0]], Mocker.CreateSessionRequest.MetaHeader.XHeaders.First().Value); + Assert.Equal(param.XHeaders[0], Mocker.CreateSessionRequest.MetaHeader.XHeaders.First().Key); + Assert.Equal(param.XHeaders[1], Mocker.CreateSessionRequest.MetaHeader.XHeaders.First().Value); Assert.Equal(Mocker.CancellationTokenSource.Token, Mocker.CancellationToken); Assert.NotNull(Mocker.DateTime); diff --git a/src/FrostFS.SDK.Tests/SessionTestsBase.cs b/src/FrostFS.SDK.Tests/Unit/SessionTestsBase.cs similarity index 81% rename from src/FrostFS.SDK.Tests/SessionTestsBase.cs rename to src/FrostFS.SDK.Tests/Unit/SessionTestsBase.cs index bd958fc..4482c2e 100644 --- a/src/FrostFS.SDK.Tests/SessionTestsBase.cs +++ b/src/FrostFS.SDK.Tests/Unit/SessionTestsBase.cs @@ -5,7 +5,7 @@ using FrostFS.SDK.Cryptography; using Microsoft.Extensions.Options; -namespace FrostFS.SDK.Tests; +namespace FrostFS.SDK.Tests.Unit; public abstract class SessionTestsBase { @@ -28,7 +28,7 @@ public abstract class SessionTestsBase ECDsaKey = key.LoadWif(); OwnerId = FrostFsOwner.FromKey(ECDsaKey); - Mocker = new SessionMocker(this.key) + Mocker = new SessionMocker(key) { PlacementPolicy = new FrostFsPlacementPolicy(true, new FrostFsReplica(1)), Version = new FrostFsVersion(2, 13) @@ -40,9 +40,9 @@ public abstract class SessionTestsBase return Client.FrostFSClient.GetTestInstance( Settings, null, - new NetworkMocker(this.key).GetMock().Object, + new NetworkMocker(key).GetMock().Object, Mocker.GetMock().Object, - new ContainerMocker(this.key).GetMock().Object, - new ObjectMocker(this.key).GetMock().Object); + new ContainerMocker(key).GetMock().Object, + new ObjectMocker(key).GetMock().Object); } }