| | | 1 | | // Copyright (c) ZeroC, Inc. |
| | | 2 | | |
| | | 3 | | using IceRpc.Transports; |
| | | 4 | | using System.Buffers; |
| | | 5 | | |
| | | 6 | | namespace IceRpc; |
| | | 7 | | |
| | | 8 | | /// <summary>Represents a property bag used to configure client and server connections.</summary> |
| | | 9 | | public record class ConnectionOptions |
| | | 10 | | { |
| | | 11 | | /// <summary>Gets or sets the dispatcher that dispatches requests received by this connection.</summary> |
| | | 12 | | /// <value>The dispatcher that dispatches requests received by this connection, or <see langword="null" /> if this |
| | | 13 | | /// connection does not accept requests.</value> |
| | 2015 | 14 | | public IDispatcher? Dispatcher { get; set; } |
| | | 15 | | |
| | | 16 | | /// <summary>Gets or sets a value indicating whether or not to enable the Ice idle check. This option is specific to |
| | | 17 | | /// the ice protocol. When the Ice idle check is enabled, a read operation on the underlying transport connection |
| | | 18 | | /// fails when this read waits for over <see cref="IceIdleTimeout" /> to receive any byte. When the Ice idle check |
| | | 19 | | /// is disabled, the <see cref="IceIdleTimeout" /> has no effect on reads: a read on the underlying transport |
| | | 20 | | /// connection can wait forever to receive a byte.</summary> |
| | | 21 | | /// <value><see langword="true"/> if the Ice idle check is enabled; otherwise, <see langword="false"/>. Defaults to |
| | | 22 | | /// <see langword="true"/>.</value> |
| | | 23 | | /// <remarks>Set to <see langword="false"/> when the peer is an Ice application using Ice 3.7 or earlier and you |
| | | 24 | | /// can't update this application to turn on HeartbeatAlways with |
| | | 25 | | /// <see href="https://archive.zeroc.com/ice/3.7/property-reference/ice-acm#id-.Ice.ACM.*v3.7-Ice.ACM.Heartbeat"/>. |
| | | 26 | | /// When this value is set to <see langword="true"/>, make sure the peer's idle timeout is equal to |
| | | 27 | | /// <see cref="IceIdleTimeout" />.</remarks> |
| | 976 | 28 | | public bool EnableIceIdleCheck { get; set; } = true; |
| | | 29 | | |
| | | 30 | | /// <summary>Gets or sets the Ice idle timeout. This option is specific to the ice protocol. Once the connection is |
| | | 31 | | /// established, the runtime sends a heartbeat to the peer when there is no write on the connection for half this |
| | | 32 | | /// Ice idle timeout.</summary> |
| | | 33 | | /// <value>The Ice idle timeout. Defaults to <c>60</c> seconds to match the default ACM configuration in Ice 3.7. |
| | | 34 | | /// </value> |
| | | 35 | | /// <seealso cref="EnableIceIdleCheck" /> |
| | | 36 | | public TimeSpan IceIdleTimeout |
| | | 37 | | { |
| | 687 | 38 | | get => _iceIdleTimeout; |
| | 3 | 39 | | set => _iceIdleTimeout = value != TimeSpan.Zero ? value : |
| | 3 | 40 | | throw new ArgumentException($"0 is not a valid value for {nameof(IceIdleTimeout)}", nameof(value)); |
| | | 41 | | } |
| | | 42 | | |
| | | 43 | | /// <summary>Gets or sets the inactivity timeout. This timeout is used to gracefully shut down the connection if |
| | | 44 | | /// it's inactive for longer than this timeout. A connection is considered inactive when there's no invocation or |
| | | 45 | | /// dispatch in progress.</summary> |
| | | 46 | | /// <value>The inactivity timeout. Defaults to <c>5</c> minutes.</value> |
| | | 47 | | public TimeSpan InactivityTimeout |
| | | 48 | | { |
| | 644 | 49 | | get => _inactivityTimeout; |
| | 11 | 50 | | set => _inactivityTimeout = value != TimeSpan.Zero ? value : |
| | 11 | 51 | | throw new ArgumentException($"0 is not a valid value for {nameof(InactivityTimeout)}", nameof(value)); |
| | | 52 | | } |
| | | 53 | | |
| | | 54 | | /// <summary>Gets or sets the maximum number of requests that a connection can dispatch concurrently. Once this |
| | | 55 | | /// limit is reached, the connection stops reading new requests off its underlying transport connection.</summary> |
| | | 56 | | /// <value>The maximum number of requests that a connection can dispatch concurrently. <c>0</c> means no maximum. |
| | | 57 | | /// Defaults to <c>100</c> requests.</value> |
| | | 58 | | /// <remarks>With the icerpc protocol, you may also need to set <see cref="MaxIceRpcBidirectionalStreams" /> and |
| | | 59 | | /// <see cref="MaxIceRpcUnidirectionalStreams" />. A typical two-way dispatch holds onto one bidirectional stream |
| | | 60 | | /// while a typical one-way dispatch quickly releases its unidirectional stream and then executes without consuming |
| | | 61 | | /// any stream.</remarks> |
| | | 62 | | public int MaxDispatches |
| | | 63 | | { |
| | 1932 | 64 | | get => _maxDispatches; |
| | 11 | 65 | | set => _maxDispatches = value >= 0 ? value : |
| | 11 | 66 | | throw new ArgumentOutOfRangeException(nameof(value), "value must be 0 or greater"); |
| | | 67 | | } |
| | | 68 | | |
| | | 69 | | /// <summary>Gets or sets the maximum size of a frame received over the ice protocol.</summary> |
| | | 70 | | /// <value>The maximum size of an incoming frame, in bytes. This value must be at least <c>256</c>. Defaults to |
| | | 71 | | /// <c>1</c> MB.</value> |
| | | 72 | | /// <remarks>This property is the counterpart of the Ice property |
| | | 73 | | /// <see href="https://docs.zeroc.com/ice/3.8/cpp/ice#Ice.MessageSizeMax">Ice.MessageSizeMax</see>: both limit |
| | | 74 | | /// the size of a whole frame, header included, and both close the connection when the size of an incoming frame |
| | | 75 | | /// exceeds this limit. Unlike Ice.MessageSizeMax, this property is expressed in bytes rather than kilobytes and |
| | | 76 | | /// cannot be set to <c>0</c> to disable the limit.</remarks> |
| | | 77 | | public int MaxIceFrameSize |
| | | 78 | | { |
| | 229 | 79 | | get => _maxIceFrameSize; |
| | 1 | 80 | | set => _maxIceFrameSize = value >= IceMinFrameSize ? value : |
| | 1 | 81 | | throw new ArgumentOutOfRangeException( |
| | 1 | 82 | | nameof(value), |
| | 1 | 83 | | $"{nameof(MaxIceFrameSize)} must be at least {IceMinFrameSize}"); |
| | | 84 | | } |
| | | 85 | | |
| | | 86 | | /// <summary>Gets or sets the maximum allowed number of simultaneous remote bidirectional streams that can be |
| | | 87 | | /// accepted on an icerpc connection. When this limit is reached, the peer is not allowed to open any new |
| | | 88 | | /// bidirectional stream. Since an bidirectional stream is opened for each two-way invocation, the sending of the |
| | | 89 | | /// two-way invocation will be delayed until another two-way invocation's stream completes.</summary> |
| | | 90 | | /// <value>The maximum number of bidirectional streams. It can't be less than <c>1</c> or greater than |
| | | 91 | | /// <c>65,535</c>. Defaults to <c>100</c>.</value> |
| | | 92 | | public int MaxIceRpcBidirectionalStreams |
| | | 93 | | { |
| | 70 | 94 | | get => _maxIceRpcBidirectionalStreams; |
| | 0 | 95 | | set => _maxIceRpcBidirectionalStreams = value is > 0 and <= ushort.MaxValue ? value : |
| | 0 | 96 | | throw new ArgumentException( |
| | 0 | 97 | | $"{nameof(MaxIceRpcBidirectionalStreams)} must be between 1 and {ushort.MaxValue}", |
| | 0 | 98 | | nameof(value)); |
| | | 99 | | } |
| | | 100 | | |
| | | 101 | | /// <summary>Gets or sets the maximum size of icerpc protocol header.</summary> |
| | | 102 | | /// <value>The maximum size in bytes of the header of an incoming request, response or control frame. Defaults to |
| | | 103 | | /// <c>16,383</c>, and the range of this value is <c>63</c> to <c>1,048,575</c>.</value> |
| | | 104 | | public int MaxIceRpcHeaderSize |
| | | 105 | | { |
| | 415 | 106 | | get => _maxIceRpcHeaderSize; |
| | 2 | 107 | | set => _maxIceRpcHeaderSize = IceRpcCheckMaxHeaderSize(value); |
| | | 108 | | } |
| | | 109 | | |
| | | 110 | | /// <summary>Gets or sets the maximum allowed number of simultaneous remote unidirectional streams that can be |
| | | 111 | | /// accepted on an icerpc connection. When this limit is reached, the peer is not allowed to open any new |
| | | 112 | | /// unidirectional stream. Since an unidirectional stream is opened for each one-way invocation, the sending of the |
| | | 113 | | /// one-way invocation will be delayed until another one-way invocation's stream completes.</summary> |
| | | 114 | | /// <value>The maximum number of unidirectional streams. It can't be less than <c>1</c> or greater than |
| | | 115 | | /// <c>65,535</c>. Defaults to <c>100</c>.</value> |
| | | 116 | | public int MaxIceRpcUnidirectionalStreams |
| | | 117 | | { |
| | 70 | 118 | | get => _maxIceRpcUnidirectionalStreams; |
| | 0 | 119 | | set => _maxIceRpcUnidirectionalStreams = value is > 0 and <= ushort.MaxValue ? value : |
| | 0 | 120 | | throw new ArgumentException( |
| | 0 | 121 | | $"{nameof(MaxIceRpcUnidirectionalStreams)} must be between 1 and {ushort.MaxValue}", |
| | 0 | 122 | | nameof(value)); |
| | | 123 | | } |
| | | 124 | | |
| | | 125 | | /// <summary>Gets or sets the minimum size of the segment requested from the <see cref="Pool" />.</summary> |
| | | 126 | | /// <value>The minimum size of the segment requested from the <see cref="Pool" />. Defaults to <c>4096</c>.</value> |
| | | 127 | | public int MinSegmentSize |
| | | 128 | | { |
| | 988 | 129 | | get => _minSegmentSize; |
| | 0 | 130 | | set => _minSegmentSize = value >= 1024 ? value : |
| | 0 | 131 | | throw new ArgumentException($"{nameof(MinSegmentSize)} can't be less than 1KB", nameof(value)); |
| | | 132 | | } |
| | | 133 | | |
| | | 134 | | /// <summary>Gets or sets the <see cref="MemoryPool{T}" /> object used by the connection for allocating memory |
| | | 135 | | /// blocks.</summary> |
| | | 136 | | /// <value>A pool of memory blocks used for buffer management. Defaults to <see cref="MemoryPool{T}.Shared" |
| | | 137 | | /// />.</value> |
| | 1735 | 138 | | public MemoryPool<byte> Pool { get; set; } = MemoryPool<byte>.Shared; |
| | | 139 | | |
| | | 140 | | /// <summary>The default value for <see cref="MaxIceRpcHeaderSize" />.</summary> |
| | | 141 | | internal const int DefaultMaxIceRpcHeaderSize = 16_383; |
| | | 142 | | |
| | | 143 | | private const int IceMinFrameSize = 256; |
| | | 144 | | |
| | 747 | 145 | | private TimeSpan _iceIdleTimeout = TimeSpan.FromSeconds(60); |
| | 747 | 146 | | private TimeSpan _inactivityTimeout = TimeSpan.FromMinutes(5); |
| | 747 | 147 | | private int _maxDispatches = 100; |
| | 747 | 148 | | private int _maxIceFrameSize = 1024 * 1024; |
| | 747 | 149 | | private int _maxIceRpcBidirectionalStreams = MultiplexedConnectionOptions.DefaultMaxBidirectionalStreams; |
| | 747 | 150 | | private int _maxIceRpcHeaderSize = DefaultMaxIceRpcHeaderSize; |
| | 747 | 151 | | private int _maxIceRpcUnidirectionalStreams = MultiplexedConnectionOptions.DefaultMaxUnidirectionalStreams; |
| | 747 | 152 | | private int _minSegmentSize = 4096; |
| | | 153 | | |
| | 5 | 154 | | internal static int IceRpcCheckMaxHeaderSize(long value) => value is >= 63 and <= 1_048_575 ? (int)value : |
| | 5 | 155 | | throw new ArgumentOutOfRangeException(nameof(value), "value must be between 63 and 1,048,575"); |
| | | 156 | | } |