TrueCloudLab/frostfs-sdk-csharp
20
1
Fork 5
Code Issues 3 Pull requests Projects Releases Packages 3 Activity Actions

[#28] Clients: Make immutable parameters
All checks were successful
lint-build / dotnet8.0 (pull_request) Successful in 55s
Details
DCO / DCO (pull_request) Successful in 1m4s
Details
lint-build / dotnet8.0 (push) Successful in 1m13s
Details

Browse source 
Signed-off-by: Pavel Gross <p.gross@yadro.com>
This commit is contained in:
Pavel Gross 2024-12-02 19:33:45 +03:00
parent 749000a090
commit 9bb7b5eff8
62 changed files with 2742 additions and 963 deletions
Download patch file Download diff file Expand all files Collapse all files

193
src/FrostFS.SDK.Client/FrostFSClient.cs
View file

@ -49,7 +49,7 @@ public class FrostFSClient : IFrostFSClient
internal ClientContext ClientCtx { get; set; }
public static IFrostFSClient GetSingleOwnerInstance(IOptions<ClientSettings> clientOptions, GrpcChannelOptions? channelOptions = null)
public static IFrostFSClient GetInstance(IOptions<ClientSettings> clientOptions, GrpcChannelOptions? channelOptions = null)
{
return new FrostFSClient(clientOptions, channelOptions);
}
@ -170,229 +170,134 @@ public class FrostFSClient : IFrostFSClient
}
#region ApeManagerImplementation
public Task<ReadOnlyMemory<byte>> AddChainAsync(PrmApeChainAdd args)
public Task<ReadOnlyMemory<byte>> 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<Chain[]> ListChainAsync(PrmApeChainList args)
public Task<Chain[]> 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<FrostFsContainerInfo> GetContainerAsync(PrmContainerGet args)
public Task<FrostFsContainerInfo> 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<FrostFsContainerId> ListContainersAsync(PrmContainerGetAll? args = null)
public IAsyncEnumerable<FrostFsContainerId> ListContainersAsync(PrmContainerGetAll args, CallContext ctx)
{
args ??= new PrmContainerGetAll();
var service = GetContainerService();
return service.ListContainersAsync(args);
return GetContainerService().ListContainersAsync(args, ctx);
}
public Task<FrostFsContainerId> CreateContainerAsync(PrmContainerCreate args)
public Task<FrostFsContainerId> 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<FrostFsNetmapSnapshot> GetNetmapSnapshotAsync(PrmNetmapSnapshot? args)
public Task<FrostFsNetmapSnapshot> GetNetmapSnapshotAsync(CallContext ctx)
{
args ??= new PrmNetmapSnapshot();
var service = GetNetmapService();
return service.GetNetmapSnapshotAsync(args);
return GetNetmapService().GetNetmapSnapshotAsync(ctx);
}
public Task<FrostFsNodeInfo> GetNodeInfoAsync(PrmNodeInfo? args)
public Task<FrostFsNodeInfo> GetNodeInfoAsync(CallContext ctx)
{
args ??= new PrmNodeInfo();
var service = GetNetmapService();
return service.GetLocalNodeInfoAsync(args);
return GetNetmapService().GetLocalNodeInfoAsync(ctx);
}
public Task<NetworkSettings> GetNetworkSettingsAsync(PrmNetworkSettings? args)
public Task<NetworkSettings> GetNetworkSettingsAsync(CallContext ctx)
{
args ??= new PrmNetworkSettings();
var service = GetNetmapService();
return service.GetNetworkSettingsAsync(args.Context!);
return GetNetmapService().GetNetworkSettingsAsync(ctx);
}
#endregion
#region ObjectImplementation
public Task<FrostFsObjectHeader> GetObjectHeadAsync(PrmObjectHeadGet args)
public Task<FrostFsHeaderResult> 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<FrostFsObject> GetObjectAsync(PrmObjectGet args)
public Task<FrostFsObject> 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<RangeReader> GetRangeAsync(PrmRangeGet args)
public Task<RangeReader> 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<ReadOnlyMemory<byte>[]> GetRangeHashAsync(PrmRangeHashGet args)
public Task<ReadOnlyMemory<byte>[]> 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<FrostFsObjectId> PutObjectAsync(PrmObjectPut args)
public Task<FrostFsObjectId> 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<FrostFsObjectId> PutSingleObjectAsync(PrmSingleObjectPut args)
public Task<FrostFsObjectId> 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<FrostFsObjectId> PatchObjectAsync(PrmObjectPatch args)
public Task<FrostFsObjectId> 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<FrostFsObjectId> SearchObjectsAsync(PrmObjectSearch args)
public IAsyncEnumerable<FrostFsObjectId> 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<FrostFsSessionToken> CreateSessionAsync(PrmSessionCreate args)
public async Task<FrostFsSessionToken> 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<SessionToken> CreateSessionInternalAsync(PrmSessionCreate args)
internal Task<SessionToken> 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<Accounting.Decimal> GetBalanceAsync(PrmBalance? args)
public async Task<Accounting.Decimal> 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<string?> 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;
}

46
src/FrostFS.SDK.Client/Interfaces/IFrostFSClient.cs
View file

@ -9,61 +9,57 @@ namespace FrostFS.SDK.Client.Interfaces;
public interface IFrostFSClient : IDisposable
{
#region Network
Task<FrostFsNetmapSnapshot> GetNetmapSnapshotAsync(PrmNetmapSnapshot? args = null);
Task<FrostFsNetmapSnapshot> GetNetmapSnapshotAsync(CallContext ctx);
Task<FrostFsNodeInfo> GetNodeInfoAsync(PrmNodeInfo? args = null);
Task<FrostFsNodeInfo> GetNodeInfoAsync(CallContext ctx);
Task<NetworkSettings> GetNetworkSettingsAsync(PrmNetworkSettings? args = null);
Task<NetworkSettings> GetNetworkSettingsAsync(CallContext ctx);
#endregion
#region Session
Task<FrostFsSessionToken> CreateSessionAsync(PrmSessionCreate args);
Task<FrostFsSessionToken> CreateSessionAsync(PrmSessionCreate args, CallContext ctx);
#endregion
#region ApeManager
Task<ReadOnlyMemory<byte>> AddChainAsync(PrmApeChainAdd args);
Task<ReadOnlyMemory<byte>> AddChainAsync(PrmApeChainAdd args, CallContext ctx);
Task RemoveChainAsync(PrmApeChainRemove args);
Task RemoveChainAsync(PrmApeChainRemove args, CallContext ctx);
Task<Chain[]> ListChainAsync(PrmApeChainList args);
Task<Chain[]> ListChainAsync(PrmApeChainList args, CallContext ctx);
#endregion
#region Container
Task<FrostFsContainerInfo> GetContainerAsync(PrmContainerGet args);
Task<FrostFsContainerInfo> GetContainerAsync(PrmContainerGet args, CallContext ctx);
IAsyncEnumerable<FrostFsContainerId> ListContainersAsync(PrmContainerGetAll? args = null);
IAsyncEnumerable<FrostFsContainerId> ListContainersAsync(PrmContainerGetAll args, CallContext ctx);
Task<FrostFsContainerId> CreateContainerAsync(PrmContainerCreate args);
Task<FrostFsContainerId> CreateContainerAsync(PrmContainerCreate args, CallContext ctx);
Task DeleteContainerAsync(PrmContainerDelete args);
Task DeleteContainerAsync(PrmContainerDelete args, CallContext ctx);
#endregion
#region Object
Task<FrostFsObjectHeader> GetObjectHeadAsync(PrmObjectHeadGet args);
Task<FrostFsHeaderResult> GetObjectHeadAsync(PrmObjectHeadGet args, CallContext ctx);
Task<FrostFsObject> GetObjectAsync(PrmObjectGet args);
Task<FrostFsObject> GetObjectAsync(PrmObjectGet args, CallContext ctx);
Task<RangeReader> GetRangeAsync(PrmRangeGet args);
Task<RangeReader> GetRangeAsync(PrmRangeGet args, CallContext ctx);
Task<ReadOnlyMemory<byte>[]> GetRangeHashAsync(PrmRangeHashGet args);
Task<ReadOnlyMemory<byte>[]> GetRangeHashAsync(PrmRangeHashGet args, CallContext ctx);
Task<FrostFsObjectId> PutObjectAsync(PrmObjectPut args);
Task<FrostFsObjectId> PutObjectAsync(PrmObjectPut args, CallContext ctx);
Task<FrostFsObjectId> PutSingleObjectAsync(PrmSingleObjectPut args);
Task<FrostFsObjectId> PutSingleObjectAsync(PrmSingleObjectPut args, CallContext ctx);
Task<FrostFsObjectId> PatchObjectAsync(PrmObjectPatch args);
Task<FrostFsObjectId> PatchObjectAsync(PrmObjectPatch args, CallContext ctx);
Task DeleteObjectAsync(PrmObjectDelete args);
Task DeleteObjectAsync(PrmObjectDelete args, CallContext ctx);
IAsyncEnumerable<FrostFsObjectId> SearchObjectsAsync(PrmObjectSearch args);
IAsyncEnumerable<FrostFsObjectId> SearchObjectsAsync(PrmObjectSearch args, CallContext ctx);
#endregion
#region Account
Task<Accounting.Decimal> GetBalanceAsync(PrmBalance? args = null);
#endregion
#region Tools
FrostFsObjectId CalculateObjectId(FrostFsObjectHeader header);
Task<Accounting.Decimal> GetBalanceAsync(CallContext ctx);
#endregion
public Task<string?> Dial(CallContext ctx);

17
src/FrostFS.SDK.Client/Models/Chain/ChainTarget.cs
View file

@ -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);
}
}

8
src/FrostFS.SDK.Client/Models/Object/FrostFsHeaderResult.cs Normal file
View file

@ -0,0 +1,8 @@
namespace FrostFS.SDK;
public class FrostFsHeaderResult
{
public FrostFsObjectHeader? HeaderInfo { get; internal set; }
public FrostFsSplitInfo? SplitInfo { get; internal set; }
}

1
src/FrostFS.SDK.Client/Models/Object/FrostFsSplit.cs
View file

@ -24,5 +24,4 @@ public class FrostFsSplit(SplitId splitId,
public FrostFsObjectHeader? ParentHeader { get; set; } = parentHeader;
public ReadOnlyCollection<FrostFsObjectId>? Children { get; } = children;
}

26
src/FrostFS.SDK.Client/Models/Object/FrostFsSplitInfo.cs Normal file
View file

@ -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);
}

38
src/FrostFS.SDK.Client/Parameters/CallContext.cs
View file

@ -3,22 +3,42 @@ using System.Threading;
namespace FrostFS.SDK.Client;
public class CallContext()
public readonly struct CallContext(TimeSpan timeout, CancellationToken cancellationToken = default) : IEquatable<CallContext>
{
public CancellationToken CancellationToken { get; } = cancellationToken;
// internal Action<Exception>? 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<CallStatistics>? Callback { get; set; }
public static bool operator ==(CallContext left, CallContext right)
{
return left.Equals(right);
}
// public Collection<Interceptor> Interceptors { get; } = [];
public static bool operator !=(CallContext left, CallContext right)
{
return !(left == right);
}
}

10
src/FrostFS.SDK.Client/Parameters/Credentials.cs
View file

@ -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;
}

11
src/FrostFS.SDK.Client/Parameters/IContext.cs
View file

@ -1,11 +0,0 @@
namespace FrostFS.SDK.Client;
public interface IContext
{
/// <summary>
/// The method call can be extended with additional behavior like canceling by timeout or user's request,
/// callbacks, interceptors.
/// </summary>
/// <value>Additional parameters for calling the method</value>
CallContext? Context { get; }
}

2
src/FrostFS.SDK.Client/Parameters/ISessionToken.cs
View file

@ -8,5 +8,5 @@ public interface ISessionToken
/// member. The session has a limited validity period, and applies to a strictly defined set of operations.
/// </summary>
/// <value>Instance of the session obtained from the server</value>
FrostFsSessionToken? SessionToken { get; set; }
FrostFsSessionToken? SessionToken { get; }
}

43
src/FrostFS.SDK.Client/Parameters/PrmApeChainAdd.cs Normal file
View file

@ -0,0 +1,43 @@
namespace FrostFS.SDK.Client;
public readonly struct PrmApeChainAdd(FrostFsChainTarget target, FrostFsChain chain, string[]? xheaders = null) : System.IEquatable<PrmApeChainAdd>
{
public FrostFsChainTarget Target { get; } = target;
public FrostFsChain Chain { get; } = chain;
/// <summary>
/// FrostFS request X-Headers
/// </summary>
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);
}
}

36
src/FrostFS.SDK.Client/Parameters/PrmApeChainList.cs
View file

@ -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<PrmApeChainList>
{
public FrostFsChainTarget Target { get; } = target;
/// <summary>
/// FrostFS request X-Headers
/// </summary>
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);
}
}

40
src/FrostFS.SDK.Client/Parameters/PrmApeChainRemove.cs
View file

@ -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<PrmApeChainRemove>
{
public FrostFsChainTarget Target { get; } = target;
public FrostFsChain Chain { get; } = chain;
/// <summary>
/// FrostFS request X-Headers
/// </summary>
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);
}
}

8
src/FrostFS.SDK.Client/Parameters/PrmApeRemoveAdd.cs
View file

@ -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;
}

5
src/FrostFS.SDK.Client/Parameters/PrmBalance.cs
View file

@ -1,5 +0,0 @@
namespace FrostFS.SDK.Client;
public sealed class PrmBalance(CallContext? ctx = null) : PrmBase(ctx)
{
}

14
src/FrostFS.SDK.Client/Parameters/PrmBase.cs
View file

@ -1,14 +0,0 @@
using System.Collections.Specialized;
namespace FrostFS.SDK.Client;
public class PrmBase(CallContext? ctx, NameValueCollection? xheaders = null) : IContext
{
/// <summary>
/// FrostFS request X-Headers
/// </summary>
public NameValueCollection XHeaders { get; } = xheaders ?? [];
/// <inheritdoc />
public CallContext Context { get; } = ctx ?? new CallContext();
}

52
src/FrostFS.SDK.Client/Parameters/PrmContainerCreate.cs
View file

@ -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<PrmContainerCreate>
{
public FrostFsContainerInfo Container { get; set; } = container;
public FrostFsContainerInfo Container { get; } = container;
/// <summary>
/// Since the container becomes available with some delay, it needs to poll the container status
/// </summary>
/// <value>Rules for polling the result</value>
public PrmWait? WaitParams { get; set; }
public PrmWait WaitParams { get; } = waitParams;
/// <summary>
/// Blank session token
/// </summary>
public FrostFsSessionToken? SessionToken { get; set; }
public FrostFsSessionToken? SessionToken { get; } = sessionToken;
/// <summary>
/// FrostFS request X-Headers
/// </summary>
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);
}
}

46
src/FrostFS.SDK.Client/Parameters/PrmContainerDelete.cs
View file

@ -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<PrmContainerDelete>
{
public FrostFsContainerId ContainerId { get; set; } = containerId;
public FrostFsContainerId ContainerId { get; } = containerId;
/// <summary>
/// Since the container is removed with some delay, it needs to poll the container status
/// </summary>
/// <value>Rules for polling the result</value>
public PrmWait? WaitParams { get; set; }
public PrmWait WaitParams { get; } = waitParams;
public FrostFsSessionToken? SessionToken { get; set; }
public FrostFsSessionToken? SessionToken { get; } = sessionToken;
/// <summary>
/// FrostFS request X-Headers
/// </summary>
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);
}
}

38
src/FrostFS.SDK.Client/Parameters/PrmContainerGet.cs
View file

@ -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<PrmContainerGet>
{
public FrostFsContainerId Container { get; set; } = container;
public FrostFsContainerId Container { get; } = container;
/// <summary>
/// FrostFS request X-Headers
/// </summary>
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);
}
}

38
src/FrostFS.SDK.Client/Parameters/PrmContainerGetAll.cs
View file

@ -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<PrmContainerGetAll>
{
/// <summary>
/// FrostFS request X-Headers
/// </summary>
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);
}
}

5
src/FrostFS.SDK.Client/Parameters/PrmNetmapSnapshot.cs
View file

@ -1,5 +0,0 @@
namespace FrostFS.SDK.Client;
public sealed class PrmNetmapSnapshot(CallContext? ctx = null) : PrmBase(ctx)
{
}

5
src/FrostFS.SDK.Client/Parameters/PrmNetworkSettings.cs
View file

@ -1,5 +0,0 @@
namespace FrostFS.SDK.Client;
public sealed class PrmNetworkSettings(CallContext? ctx = null) : PrmBase(ctx)
{
}

5
src/FrostFS.SDK.Client/Parameters/PrmNodeInfo.cs
View file

@ -1,5 +0,0 @@
namespace FrostFS.SDK.Client;
public sealed class PrmNodeInfo(CallContext? ctx = null) : PrmBase(ctx)
{
}

48
src/FrostFS.SDK.Client/Parameters/PrmObjectDelete.cs
View file

@ -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<PrmObjectDelete>
{
public FrostFsContainerId ContainerId { get; set; } = containerId;
public FrostFsContainerId ContainerId { get; } = containerId;
public FrostFsObjectId ObjectId { get; set; } = objectId;
public FrostFsObjectId ObjectId { get; } = objectId;
/// <inheritdoc />
public FrostFsSessionToken? SessionToken { get; set; }
public FrostFsSessionToken? SessionToken { get; } = sessionToken;
/// <summary>
/// FrostFS request X-Headers
/// </summary>
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);
}
}

49
src/FrostFS.SDK.Client/Parameters/PrmObjectGet.cs
View file

@ -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<PrmObjectGet>
{
public FrostFsContainerId ContainerId { get; set; } = containerId;
public FrostFsContainerId ContainerId { get; } = containerId;
public FrostFsObjectId ObjectId { get; set; } = objectId;
public FrostFsObjectId ObjectId { get; } = objectId;
/// <inheritdoc />
public FrostFsSessionToken? SessionToken { get; set; }
public FrostFsSessionToken? SessionToken { get; } = sessionToken;
/// <summary>
/// FrostFS request X-Headers
/// </summary>
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);
}
}

53
src/FrostFS.SDK.Client/Parameters/PrmObjectHeadGet.cs
View file

@ -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<PrmObjectHeadGet>
{
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;
/// <inheritdoc />
public FrostFsSessionToken? SessionToken { get; set; }
public FrostFsSessionToken? SessionToken { get; } = sessionToken;
/// <summary>
/// FrostFS request X-Headers
/// </summary>
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);
}
}

61
src/FrostFS.SDK.Client/Parameters/PrmObjectPatch.cs
View file

@ -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<PrmObjectPatch>
{
public FrostFsAddress Address { get; } = address;
public FrostFsRange Range { get; set; }
public FrostFsRange Range { get; } = range;
/// <summary>
/// A stream with source data
/// </summary>
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;
/// <inheritdoc />
public FrostFsSessionToken? SessionToken { get; set; }
public FrostFsSessionToken? SessionToken { get; } = sessionToken;
/// <summary>
/// FrostFS request X-Headers
/// </summary>
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);
}
}

62
src/FrostFS.SDK.Client/Parameters/PrmObjectPut.cs
View file

@ -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<PrmObjectPut>
{
/// <summary>
/// Need to provide values like <c>ContainerId</c> and <c>ObjectType</c> to create and object.
/// Optional parameters ike <c>Attributes</c> can be provided as well.
/// </summary>
/// <value>Header with required parameters to create an object</value>
public FrostFsObjectHeader? Header { get; set; }
public FrostFsObjectHeader? Header { get; } = header;
/// <summary>
/// A stream with source data
/// </summary>
public Stream? Payload { get; set; }
public Stream? Payload { get; } = payload;
/// <summary>
/// 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.
/// </summary>
/// <value>Is client cut is applied</value>
public bool ClientCut { get; set; }
public bool ClientCut { get; } = clientCut;
/// <summary>
/// Overrides default size of the buffer for stream transferring.
/// </summary>
/// <value>Size of the buffer</value>
public int BufferMaxSize { get; set; }
public int BufferMaxSize { get; } = bufferMaxSize;
/// <summary>
/// Allows to define a buffer for chunks to manage by the memory allocation and releasing.
/// </summary>
public byte[]? CustomBuffer { get; set; }
public byte[]? CustomBuffer { get; } = customBuffer;
/// <inheritdoc />
public FrostFsSessionToken? SessionToken { get; set; }
public FrostFsSessionToken? SessionToken { get; } = sessionToken;
internal int MaxObjectSizeCache { get; set; }
/// <summary>
/// FrostFS request X-Headers
/// </summary>
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);
}
}

52
src/FrostFS.SDK.Client/Parameters/PrmObjectSearch.cs
View file

@ -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<PrmObjectSearch>
{
/// <summary>
/// Defines container for the search
/// </summary>
/// <value></value>
public FrostFsContainerId ContainerId { get; set; } = containerId;
public FrostFsContainerId ContainerId { get; } = containerId;
/// <summary>
/// Defines the search criteria
/// </summary>
/// <value>Collection of filters</value>
public IEnumerable<IObjectFilter> Filters { get; set; } = filters;
public IObjectFilter[] Filters { get; } = filters;
/// <inheritdoc />
public FrostFsSessionToken? SessionToken { get; set; }
public FrostFsSessionToken? SessionToken { get; } = token;
/// <summary>
/// FrostFS request X-Headers
/// </summary>
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);
}
}

43
src/FrostFS.SDK.Client/Parameters/PrmRangeGet.cs
View file

@ -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<PrmRangeGet>
{
public FrostFsContainerId ContainerId { get; } = containerId;
@ -16,5 +17,41 @@ public sealed class PrmRangeGet(
public bool Raw { get; } = raw;
/// <inheritdoc />
public FrostFsSessionToken? SessionToken { get; set; }
public FrostFsSessionToken? SessionToken { get; } = sessionToken;
/// <summary>
/// FrostFS request X-Headers
/// </summary>
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);
}
}

44
src/FrostFS.SDK.Client/Parameters/PrmRangeHashGet.cs
View file

@ -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<PrmRangeHashGet>
{
public FrostFsContainerId ContainerId { get; } = containerId;
@ -16,5 +17,42 @@ public sealed class PrmRangeHashGet(
public byte[] Salt { get; } = salt;
/// <inheritdoc />
public FrostFsSessionToken? SessionToken { get; set; }
public FrostFsSessionToken? SessionToken { get; } = sessionToken;
/// <summary>
/// FrostFS request X-Headers
/// </summary>
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);
}
}

38
src/FrostFS.SDK.Client/Parameters/PrmSessionCreate.cs
View file

@ -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<PrmSessionCreate>
{
public ulong Expiration { get; set; } = expiration;
public ulong Expiration { get; } = expiration;
/// <summary>
/// FrostFS request X-Headers
/// </summary>
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);
}
}

39
src/FrostFS.SDK.Client/Parameters/PrmSingleObjectPut.cs
View file

@ -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<PrmSingleObjectPut>
{
public FrostFsObject FrostFsObject { get; set; } = frostFsObject;
/// <inheritdoc />
public FrostFsSessionToken? SessionToken { get; set; }
/// <summary>
/// FrostFS request X-Headers
/// </summary>
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);
}
}

36
src/FrostFS.SDK.Client/Parameters/PrmWait.cs
View file

@ -2,7 +2,7 @@
namespace FrostFS.SDK.Client;
public class PrmWait(TimeSpan timeout, TimeSpan pollInterval)
public readonly struct PrmWait(TimeSpan timeout, TimeSpan pollInterval) : IEquatable<PrmWait>
{
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);
}
}

10
src/FrostFS.SDK.Client/Parameters/PutObjectContext.cs Normal file
View file

@ -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; }
}

12
src/FrostFS.SDK.Client/Pool/ClientWrapper.cs
View file

@ -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)
{

103
src/FrostFS.SDK.Client/Pool/Pool.cs
View file

@ -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<FrostFsSessionToken> 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<FrostFsNetmapSnapshot> GetNetmapSnapshotAsync(PrmNetmapSnapshot? args = null)
public async Task<FrostFsNetmapSnapshot> 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<FrostFsNodeInfo> GetNodeInfoAsync(PrmNodeInfo? args = null)
public async Task<FrostFsNodeInfo> 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<NetworkSettings> GetNetworkSettingsAsync(PrmNetworkSettings? args = null)
public async Task<NetworkSettings> 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<FrostFsSessionToken> CreateSessionAsync(PrmSessionCreate args)
public async Task<FrostFsSessionToken> 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<ReadOnlyMemory<byte>> AddChainAsync(PrmApeChainAdd args)
public async Task<ReadOnlyMemory<byte>> 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<Chain[]> ListChainAsync(PrmApeChainList args)
public async Task<Chain[]> 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<FrostFsContainerInfo> GetContainerAsync(PrmContainerGet args)
public async Task<FrostFsContainerInfo> 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<FrostFsContainerId> ListContainersAsync(PrmContainerGetAll? args = null)
public IAsyncEnumerable<FrostFsContainerId> ListContainersAsync(PrmContainerGetAll args, CallContext ctx)
{
var client = Connection();
return client.Client!.ListContainersAsync(args);
return client.Client!.ListContainersAsync(args, ctx);
}
public async Task<FrostFsContainerId> CreateContainerAsync(PrmContainerCreate args)
public async Task<FrostFsContainerId> 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<FrostFsObjectHeader> GetObjectHeadAsync(PrmObjectHeadGet args)
public async Task<FrostFsHeaderResult> 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<FrostFsObject> GetObjectAsync(PrmObjectGet args)
public async Task<FrostFsObject> 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<FrostFsObjectId> PutObjectAsync(PrmObjectPut args)
public async Task<FrostFsObjectId> 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<FrostFsObjectId> PutSingleObjectAsync(PrmSingleObjectPut args)
public async Task<FrostFsObjectId> 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<FrostFsObjectId> PatchObjectAsync(PrmObjectPatch args)
public async Task<FrostFsObjectId> 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<RangeReader> GetRangeAsync(PrmRangeGet args)
public async Task<RangeReader> 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<ReadOnlyMemory<byte>[]> GetRangeHashAsync(PrmRangeHashGet args)
public async Task<ReadOnlyMemory<byte>[]> 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<FrostFsObjectId> PatchAsync(PrmObjectPatch args)
public async Task<FrostFsObjectId> 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<FrostFsObjectId> SearchObjectsAsync(PrmObjectSearch args)
public IAsyncEnumerable<FrostFsObjectId> SearchObjectsAsync(PrmObjectSearch args, CallContext ctx)
{
var client = Connection();
return client.Client!.SearchObjectsAsync(args);
return client.Client!.SearchObjectsAsync(args, ctx);
}
public async Task<Accounting.Decimal> GetBalanceAsync(PrmBalance? args)
public async Task<Accounting.Decimal> 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();
}
}

8
src/FrostFS.SDK.Client/Services/AccountingServiceProvider.cs
View file

@ -16,10 +16,8 @@ internal sealed class AccountingServiceProvider : ContextAccessor
_accountingServiceClient = accountingServiceClient;
}
internal async Task<Decimal> GetBallance(PrmBalance args)
internal async Task<Decimal> 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);

18
src/FrostFS.SDK.Client/Services/ApeManagerServiceProvider.cs
View file

@ -16,10 +16,8 @@ internal sealed class ApeManagerServiceProvider : ContextAccessor
_apeManagerServiceClient = apeManagerServiceClient;
}
internal async Task<ReadOnlyMemory<byte>> AddChainAsync(PrmApeChainAdd args)
internal async Task<ReadOnlyMemory<byte>> 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<Chain[]> ListChainAsync(PrmApeChainList args)
internal async Task<Chain[]> 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);

34
src/FrostFS.SDK.Client/Services/ContainerServiceProvider.cs
View file

@ -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<FrostFsContainerInfo> GetContainerAsync(PrmContainerGet args)
internal async Task<FrostFsContainerInfo> 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<FrostFsContainerId> ListContainersAsync(PrmContainerGetAll args)
internal async IAsyncEnumerable<FrostFsContainerId> 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<FrostFsContainerId> CreateContainerAsync(PrmContainerCreate args)
internal async Task<FrostFsContainerId> 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<Task> action,
WaitExpects expect,
PrmWait? waitParams)
PrmWait waitParams)
{
waitParams ??= PrmWait.DefaultParams;
var deadLine = waitParams.GetDeadline();
while (true)

20
src/FrostFS.SDK.Client/Services/NetmapServiceProvider.cs
View file

@ -42,19 +42,17 @@ internal sealed class NetmapServiceProvider : ContextAccessor
return settings;
}
internal async Task<FrostFsNodeInfo> GetLocalNodeInfoAsync(PrmNodeInfo args)
internal async Task<FrostFsNodeInfo> 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<FrostFsNetmapSnapshot> GetNetmapSnapshotAsync(PrmNetmapSnapshot args)
internal async Task<FrostFsNetmapSnapshot> 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);

125
src/FrostFS.SDK.Client/Services/ObjectServiceProvider.cs
View file

@ -43,10 +43,8 @@ internal sealed class ObjectServiceProvider(ObjectService.ObjectServiceClient cl
return token;
}
internal async Task<FrostFsObjectHeader> GetObjectHeadAsync(PrmObjectHeadGet args)
internal async Task<FrostFsHeaderResult> 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<FrostFsObject> GetObjectAsync(PrmObjectGet args)
internal async Task<FrostFsObject> 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<RangeReader> GetRangeAsync(PrmRangeGet args)
internal async Task<RangeReader> 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<ReadOnlyMemory<byte>[]> GetRangeHashAsync(PrmRangeHashGet args)
internal async Task<ReadOnlyMemory<byte>[]> 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<FrostFsObjectId> SearchObjectsAsync(PrmObjectSearch args)
internal async IAsyncEnumerable<FrostFsObjectId> 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<FrostFsObjectId> PutObjectAsync(PrmObjectPut args)
internal async Task<FrostFsObjectId> 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<FrostFsObjectId> PutSingleObjectAsync(PrmSingleObjectPut args)
internal async Task<FrostFsObjectId> 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<FrostFsObjectId> PatchObjectAsync(PrmObjectPatch args)
internal async Task<FrostFsObjectId> 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<FrostFsObjectId> PutClientCutObject(PrmObjectPut args)
private async Task<FrostFsObjectId> 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<FrostFsObjectId> 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<PutObjectResult> PutStreamObject(PrmObjectPut args)
private async Task<PutObjectResult> 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);
}

8
src/FrostFS.SDK.Client/Services/SessionServiceProvider.cs
View file

@ -14,10 +14,8 @@ internal sealed class SessionServiceProvider : ContextAccessor
_sessionServiceClient = sessionServiceClient;
}
internal async Task<SessionToken> CreateSessionAsync(PrmSessionCreate args)
internal async Task<SessionToken> 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<SessionToken> 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);

2
src/FrostFS.SDK.Client/Services/Shared/SessionProvider.cs
View file

@ -18,6 +18,6 @@ internal sealed class SessionProvider(ClientContext envCtx)
internal async Task<Session.SessionToken> 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);
}
}

10
src/FrostFS.SDK.Client/Tools/ObjectTools.cs
View file

@ -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;

18
src/FrostFS.SDK.Client/Tools/RequestConstructor.cs
View file

@ -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<string>().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] });
}
}
}
}