public RequestPipeline(
ITransportConfigurationValues configurationValues,
IDateTimeProvider dateTimeProvider,
IMemoryStreamFactory memoryStreamFactory,
IRequestParameters requestParameters
)
{
_settings = configurationValues;
_connectionPool = _settings.ConnectionPool;
_connection = _settings.Connection;
_dateTimeProvider = dateTimeProvider;
_memoryStreamFactory = memoryStreamFactory;
_productRegistration = configurationValues.ProductRegistration;
_nodePredicate = _settings.NodePredicate ?? _productRegistration.NodePredicate;
RequestConfiguration = requestParameters?.RequestConfiguration;
PingRequestConfiguration = new RequestConfiguration
{
PingTimeout = PingTimeout,
RequestTimeout = PingTimeout,
BasicAuthenticationCredentials = _settings.BasicAuthenticationCredentials,
ApiKeyAuthenticationCredentials = _settings.ApiKeyAuthenticationCredentials,
EnableHttpPipelining = RequestConfiguration?.EnableHttpPipelining ?? _settings.HttpPipeliningEnabled,
ForceNode = RequestConfiguration?.ForceNode
};
StartedOn = dateTimeProvider.Now();
}
string IUrlParameter.GetString(ITransportConfigurationValues settings) => Match(
all => "_all",
many =>
{
if (!(settings is IConnectionSettingsValues nestSettings))
{
throw new Exception(
public override async Task WriteAsync(Stream writableStream, ITransportConfigurationValues settings,
CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(_literalString))
{
return;
}
var stream = InitWrite(writableStream, settings, out var buffer, out var disableDirectStreaming);
var stringBytes = WrittenBytes ?? _literalString.Utf8Bytes();
WrittenBytes ??= stringBytes;
if (!disableDirectStreaming)
{
await stream.WriteAsync(stringBytes, 0, stringBytes.Length, cancellationToken)
.ConfigureAwait(false);
}
else
{
buffer = settings.MemoryStreamFactory.Create(stringBytes);
}
await FinishStreamAsync(writableStream, buffer, settings, cancellationToken).ConfigureAwait(false);
}
public override void Write(Stream writableStream, ITransportConfigurationValues settings)
{
MemoryStream buffer = null;
var stream = writableStream;
BufferIfNeeded(settings, ref buffer, ref stream);
_syncWriter(_state, stream);
FinishStream(writableStream, buffer, settings);
}
public FixedPipelineFactory(ITransportConfigurationValues connectionSettings, IDateTimeProvider dateTimeProvider)
{
DateTimeProvider = dateTimeProvider;
MemoryStreamFactory = TransportConfiguration.DefaultMemoryStreamFactory;
Settings = connectionSettings;
Pipeline = Create(Settings, DateTimeProvider, MemoryStreamFactory, new RequestParameters(HttpMethod.GET, supportsBody: false));
Transport = new Transport <ITransportConfigurationValues>(Settings, this, DateTimeProvider, MemoryStreamFactory);
}
public string GetString(ITransportConfigurationValues settings)
{
if (!(settings is IConnectionSettingsValues nestSettings))
{
throw new Exception("Tried to pass index name on querystring but it could not be resolved because no nest settings are available");
}
return(nestSettings.Inferrer.IndexName(this));
}
public override async Task WriteAsync(Stream writableStream, ITransportConfigurationValues settings, CancellationToken cancellationToken)
{
MemoryStream buffer = null;
var stream = writableStream;
BufferIfNeeded(settings, ref buffer, ref stream);
await _asyncWriter(_state, stream, cancellationToken).ConfigureAwait(false);
await FinishStreamAsync(writableStream, buffer, settings, cancellationToken).ConfigureAwait(false);
}
/// <summary> Sets up the stream and buffer and determines if direct streaming should be disabled </summary>
// ReSharper disable once MemberCanBePrivate.Global
protected Stream InitWrite(Stream writableStream, ITransportConfigurationValues settings, out MemoryStream buffer,
out bool disableDirectStreaming)
{
buffer = null;
var stream = writableStream;
disableDirectStreaming = DisableDirectStreaming ?? settings.DisableDirectStreaming;
return(stream);
}
string IUrlParameter.GetString(ITransportConfigurationValues settings)
{
if (!(settings is IConnectionSettingsValues nestSettings))
{
throw new ArgumentNullException(nameof(settings),
$"Can not resolve {nameof(Field)} if no {nameof(IConnectionSettingsValues)} is provided");
}
return(nestSettings.Inferrer.Field(this));
}
protected void BufferIfNeeded(ITransportConfigurationValues settings, ref MemoryStream buffer, ref Stream stream)
{
var disableDirectStreaming = DisableDirectStreaming ?? settings.DisableDirectStreaming;
if (!disableDirectStreaming)
{
return;
}
buffer = settings.MemoryStreamFactory.Create();
stream = buffer;
}
public override async Task WriteAsync(Stream writableStream, ITransportConfigurationValues settings, CancellationToken cancellationToken)
{
MemoryStream buffer = null;
var stream = writableStream;
BufferIfNeeded(settings, ref buffer, ref stream);
var indent = settings.PrettyJson ? Indented : None;
await settings.RequestResponseSerializer.SerializeAsync(_serializable, stream, indent, cancellationToken)
.ConfigureAwait(false);
await FinishStreamAsync(writableStream, buffer, settings, cancellationToken).ConfigureAwait(false);
}
/// <summary>
/// Implementation of <see cref="Write"/> may call this to make sure <paramref name="buffer"/> makes it to <see cref="WrittenBytes"/>
/// if <see cref="DisableDirectStreaming"/> or <paramref name="settings"/> request to buffer the data.
/// </summary>
protected void FinishStream(Stream writableStream, MemoryStream buffer, ITransportConfigurationValues settings)
{
var disableDirectStreaming = DisableDirectStreaming ?? settings.DisableDirectStreaming;
if (buffer == null || !disableDirectStreaming)
{
return;
}
buffer.Position = 0;
buffer.CopyTo(writableStream, BufferSize);
WrittenBytes ??= buffer.ToArray();
}
public RequestData(
HttpMethod method, string path,
PostData data,
ITransportConfigurationValues global,
IRequestParameters local,
IMemoryStreamFactory memoryStreamFactory
)
: this(method, data, global, local?.RequestConfiguration, memoryStreamFactory)
{
_path = path;
CustomResponseBuilder = local?.CustomResponseBuilder;
PathAndQuery = CreatePathWithQueryStrings(path, ConnectionSettings, local);
}
public override void Write(Stream writableStream, ITransportConfigurationValues settings)
{
MemoryStream buffer = null;
var stream = writableStream;
BufferIfNeeded(settings, ref buffer, ref stream);
var indent = settings.PrettyJson ? Indented : None;
settings.RequestResponseSerializer.Serialize(_serializable, stream, indent);
FinishStream(writableStream, buffer, settings);
}
FinishStreamAsync(Stream writableStream, MemoryStream buffer, ITransportConfigurationValues settings, CancellationToken ctx)
{
var disableDirectStreaming = DisableDirectStreaming ?? settings.DisableDirectStreaming;
if (buffer == null || !disableDirectStreaming)
{
return;
}
buffer.Position = 0;
await buffer.CopyToAsync(writableStream, BufferSize, ctx).ConfigureAwait(false);
WrittenBytes ??= buffer.ToArray();
}
string IUrlParameter.GetString(ITransportConfigurationValues settings)
{
if (this == MinusOne)
{
return("-1");
}
if (this == Zero)
{
return("0");
}
if (Factor.HasValue && Interval.HasValue)
{
return(ToString());
}
return(Milliseconds.ToString());
}
public override void Write(Stream writableStream, ITransportConfigurationValues settings)
{
if (WrittenBytes == null)
{
return;
}
var stream = InitWrite(writableStream, settings, out var buffer, out var disableDirectStreaming);
if (!disableDirectStreaming)
{
stream.Write(WrittenBytes, 0, WrittenBytes.Length);
}
else
{
buffer = settings.MemoryStreamFactory.Create(WrittenBytes);
}
FinishStream(writableStream, buffer, settings);
}
public override void Write(Stream writableStream, ITransportConfigurationValues settings)
{
if (_memoryOfBytes.IsEmpty)
{
return;
}
var stream = InitWrite(writableStream, settings, out var buffer, out var disableDirectStreaming);
if (!disableDirectStreaming)
{
stream.Write(_memoryOfBytes.Span);
}
else
{
WrittenBytes ??= _memoryOfBytes.Span.ToArray();
buffer = settings.MemoryStreamFactory.Create(WrittenBytes);
}
FinishStream(writableStream, buffer, settings);
}
public override async Task WriteAsync(Stream writableStream, ITransportConfigurationValues settings,
CancellationToken cancellationToken)
{
if (WrittenBytes == null)
{
return;
}
var stream = InitWrite(writableStream, settings, out var buffer, out var disableDirectStreaming);
if (!disableDirectStreaming)
{
await stream.WriteAsync(WrittenBytes, 0, WrittenBytes.Length, cancellationToken)
.ConfigureAwait(false);
}
else
{
buffer = settings.MemoryStreamFactory.Create(WrittenBytes);
}
await FinishStreamAsync(writableStream, buffer, settings, cancellationToken).ConfigureAwait(false);
}
public override async Task WriteAsync(Stream writableStream, ITransportConfigurationValues settings,
CancellationToken cancellationToken)
{
if (_memoryOfBytes.IsEmpty)
{
return;
}
var stream = InitWrite(writableStream, settings, out var buffer, out var disableDirectStreaming);
if (!disableDirectStreaming)
{
stream.Write(_memoryOfBytes.Span);
}
else
{
WrittenBytes ??= _memoryOfBytes.Span.ToArray();
buffer = settings.MemoryStreamFactory.Create(WrittenBytes);
}
await FinishStreamAsync(writableStream, buffer, settings, cancellationToken).ConfigureAwait(false);
}
public override void Write(Stream writableStream, ITransportConfigurationValues settings)
{
if (string.IsNullOrEmpty(_literalString))
{
return;
}
var stream = InitWrite(writableStream, settings, out var buffer, out var disableDirectStreaming);
var stringBytes = WrittenBytes ?? _literalString.Utf8Bytes();
WrittenBytes ??= stringBytes;
if (!disableDirectStreaming)
{
stream.Write(stringBytes, 0, stringBytes.Length);
}
else
{
buffer = settings.MemoryStreamFactory.Create(stringBytes);
}
FinishStream(writableStream, buffer, settings);
}
// TODO This feels like its in the wrong place
private string CreatePathWithQueryStrings(string path, ITransportConfigurationValues global, IRequestParameters request)
{
path ??= string.Empty;
if (path.Contains("?"))
{
throw new ArgumentException($"{nameof(path)} can not contain querystring parameters and needs to be already escaped");
}
var g = global.QueryStringParameters;
var l = request?.QueryString;
if ((g == null || g.Count == 0) && (l == null || l.Count == 0))
{
return(path);
}
//create a copy of the global query string collection if needed.
var nv = g == null ? new NameValueCollection() : new NameValueCollection(g);
//set all querystring pairs from local `l` on the querystring collection
var formatter = ConnectionSettings.UrlFormatter;
nv.UpdateFromDictionary(l, formatter);
//if nv has no keys simply return path as provided
if (!nv.HasKeys())
{
return(path);
}
//create string for query string collection where key and value are escaped properly.
var queryString = ToQueryString(nv);
path += queryString;
return(path);
}
string IUrlParameter.GetString(ITransportConfigurationValues settings) =>
string.Join(",", Value.Cast <IUrlParameter>().Select(n => n.GetString(settings)));
public IRequestPipeline Create(ITransportConfigurationValues configurationValues, IDateTimeProvider dateTimeProvider,
IMemoryStreamFactory memoryStreamFactory, IRequestParameters requestParameters
) =>
new RequestPipeline(configurationValues, dateTimeProvider, memoryStreamFactory, requestParameters);
string IUrlParameter.GetString(ITransportConfigurationValues settings) => string.Join(",", Value);
public UrlFormatter(ITransportConfigurationValues settings) => _settings = settings;
public string GetString(ITransportConfigurationValues settings) => FullyQualifiedId;
string IUrlParameter.GetString(ITransportConfigurationValues settings) => Value;
public RequestData CreatePingRequestData(Node node, RequestConfiguration requestConfiguration, ITransportConfigurationValues global,
IMemoryStreamFactory memoryStreamFactory
)
{
IRequestParameters requestParameters = new RequestParameters(HttpMethod.HEAD, supportsBody: false);
requestParameters.RequestConfiguration = requestConfiguration;
var data = new RequestData(HttpMethod.HEAD, string.Empty, null, global, requestParameters, memoryStreamFactory)
{
Node = node
};
return(data);
}
public RequestData CreateSniffRequestData(Node node, IRequestConfiguration requestConfiguration, ITransportConfigurationValues settings,
IMemoryStreamFactory memoryStreamFactory
)
{
var requestParameters = new RequestParameters(HttpMethod.GET, supportsBody: false)
{
QueryString = { { "timeout", requestConfiguration.PingTimeout }, { "flat_settings", true }, }
};
return(new RequestData(HttpMethod.GET, SniffPath, null, settings, requestParameters, memoryStreamFactory)
{
Node = node
});
}
