| #region License |
| |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| #endregion |
| |
| using System; |
| using Gremlin.Net.Driver.Exceptions; |
| |
| namespace Gremlin.Net.Driver |
| { |
| /// <summary> |
| /// Holds settings for the <see cref="ConnectionPool"/>. |
| /// </summary> |
| public class ConnectionPoolSettings |
| { |
| private int _poolSize = DefaultPoolSize; |
| private int _maxInProcessPerConnection = DefaultMaxInProcessPerConnection; |
| private int _reconnectionAttempts = DefaultReconnectionAttempts; |
| private TimeSpan _reconnectionBaseDelay = DefaultReconnectionBaseDelay; |
| private const int DefaultPoolSize = 8; |
| private const int DefaultMaxInProcessPerConnection = 16; |
| private const int DefaultReconnectionAttempts = 4; |
| private static readonly TimeSpan DefaultReconnectionBaseDelay = TimeSpan.FromSeconds(1); |
| internal const bool DefaultEnableUserAgentOnConnect = true; |
| |
| /// <summary> |
| /// Gets or sets the size of the connection pool. |
| /// </summary> |
| /// <exception cref="ArgumentOutOfRangeException">The specified pool size is less than or equal to zero.</exception> |
| /// <remarks> |
| /// The default value is 8. |
| /// </remarks> |
| public int PoolSize |
| { |
| get => _poolSize; |
| set |
| { |
| if (value <= 0) |
| throw new ArgumentOutOfRangeException(nameof(PoolSize), $"{nameof(PoolSize)} must be > 0!"); |
| _poolSize = value; |
| } |
| } |
| |
| /// <summary> |
| /// Gets or sets the maximum number of in-flight requests that can occur on a connection. |
| /// </summary> |
| /// <exception cref="ArgumentOutOfRangeException">The specified number is less than or equal to zero.</exception> |
| /// <remarks> |
| /// The default value is 16. A <see cref="ConnectionPoolBusyException" /> is thrown if this limit is reached |
| /// on all connections when a new request comes in. |
| /// </remarks> |
| public int MaxInProcessPerConnection |
| { |
| get => _maxInProcessPerConnection; |
| set |
| { |
| if (value <= 0) |
| throw new ArgumentOutOfRangeException(nameof(MaxInProcessPerConnection), |
| $"{nameof(MaxInProcessPerConnection)} must be > 0!"); |
| _maxInProcessPerConnection = value; |
| } |
| } |
| |
| /// <summary> |
| /// Gets or sets the number of attempts to get an open connection from the pool to submit a request. |
| /// </summary> |
| /// <exception cref="ArgumentOutOfRangeException">The number of attempts specified is less than zero.</exception> |
| /// <remarks> |
| /// The driver always tries to reconnect to a server in the background after it has noticed that a |
| /// connection is dead. This setting only specifies how often the driver will retry to get an open |
| /// connection from its pool when no open connection is available to submit a request. |
| /// These retries give the driver time to establish new connections to the server that might have been |
| /// unavailable temporarily or that might have closed the connections, e.g., because they were idle for some |
| /// time. |
| /// |
| /// The default value is 4. A <see cref="ServerUnavailableException" /> is thrown if the server can still |
| /// not be reached after this many retry attempts. |
| /// |
| /// Setting this to zero means that the exception is thrown immediately when no open connection is available |
| /// to submit a request. The driver will however still try to reconnect to the server in the background for |
| /// subsequent requests. |
| /// </remarks> |
| public int ReconnectionAttempts |
| { |
| get => _reconnectionAttempts; |
| set |
| { |
| if (value < 0) |
| throw new ArgumentOutOfRangeException(nameof(ReconnectionAttempts), |
| $"{ReconnectionAttempts} must be >= 0!"); |
| _reconnectionAttempts = value; |
| } |
| } |
| |
| /// <summary> |
| /// Gets or sets the base delay used for the exponential backoff for the reconnection attempts. |
| /// </summary> |
| /// <exception cref="ArgumentOutOfRangeException">The specified delay is negative or zero.</exception> |
| /// <remarks> |
| /// The driver employs an exponential backoff strategy that uses this base delay for its reconnection |
| /// attempts. With a base delay of 100 ms for example, retries happen after 100 ms, 200 ms, 400 ms, 800 ms, |
| /// and so on, assuming that enough <see cref="ReconnectionAttempts"/> are configured. |
| /// |
| /// The default value is 1 second. |
| /// </remarks> |
| public TimeSpan ReconnectionBaseDelay |
| { |
| get => _reconnectionBaseDelay; |
| set |
| { |
| if (value <= TimeSpan.Zero) |
| throw new ArgumentOutOfRangeException(nameof(ReconnectionBaseDelay), |
| $"{nameof(ReconnectionBaseDelay)} must be > 0!"); |
| _reconnectionBaseDelay = value; |
| } |
| } |
| |
| /// <summary> |
| /// Gets or sets whether a connection pool will send a user agent during web socket handshakes |
| /// </summary> |
| /// <remarks> |
| /// The default value is true. When enabled, user agents will only be sent during the web socket |
| /// handshake. User agent follows the form: |
| /// [Application Name] [GLV Name].[Version] [Language Runtime Version] [OS].[Version] [CPU Architecture] |
| /// </remarks> |
| public bool EnableUserAgentOnConnect { get; set; } = DefaultEnableUserAgentOnConnect; |
| } |
| } |