private string CreateQueryUrl(string commandOrQuery, string db, InfluxQueryOptions options) { var epochPart = options.Epoch.HasValue ? $"&epoch={options.Precision.GetQueryParameter()}" : ""; var chunkPart = options.ChunkSize.HasValue ? $"&chunk_size={options.ChunkSize.Value}" : ""; var precisionPart = $"&precision={options.Precision.GetQueryParameter()}"; var queryPart = $"q={Uri.EscapeDataString(commandOrQuery)}"; var dbPart = string.IsNullOrEmpty(db) ? "" : $"db={Uri.EscapeDataString(db)}&"; return("query?" + dbPart + queryPart + precisionPart + chunkPart + epochPart); }
private string CreateQueryUrl(string commandOrQuery, string db, InfluxQueryOptions options) { if (options.ChunkSize.HasValue) { return($"query?db={Uri.EscapeDataString( db )}&q={Uri.EscapeDataString( commandOrQuery )}&precision={options.Precision.GetQueryParameter()}&chunk_size={options.ChunkSize.Value}"); } else { return($"query?db={Uri.EscapeDataString( db )}&q={Uri.EscapeDataString( commandOrQuery )}&precision={options.Precision.GetQueryParameter()}"); } }
private string CreateQueryUrl(string commandOrQuery, string db, InfluxQueryOptions options) { var query = $"query?db={Uri.EscapeDataString( db )}&q={Uri.EscapeDataString( commandOrQuery )}"; if (options.Precision.HasValue) { query += $"&epoch={options.Precision.Value.GetQueryParameter()}"; } if (options.ChunkSize.HasValue) { query += $"&chunk_size={options.ChunkSize.Value}"; } return(query); }
private InfluxClient(Uri endpoint, string username, string password, HttpClient client, bool disposeHttpClient) { _disposeHttpClientHandler = disposeHttpClient; _seriesMetaCache = new Dictionary <DatabaseMeasurementInfoKey, DatabaseMeasurementInfo>(); _endpoint = endpoint; _client = client; DefaultWriteOptions = new InfluxWriteOptions(); DefaultQueryOptions = new InfluxQueryOptions(); TimestampParserRegistry = new DefaultTimestampParserRegistry(); if (!string.IsNullOrEmpty(username) && !string.IsNullOrEmpty(password)) { var encoding = Encoding.GetEncoding("ISO-8859-1"); var credentials = username + ":" + password; var encodedCredentialBytes = encoding.GetBytes(credentials); var encodedCredentials = Convert.ToBase64String(encodedCredentialBytes); _authzHeader = new AuthenticationHeaderValue("Basic", encodedCredentials); } }
/// <summary> /// Constructs an InfluxClient that uses the specified credentials. /// </summary> /// <param name="endpoint"></param> /// <param name="username"></param> /// <param name="password"></param> public InfluxClient(Uri endpoint, string username, string password) { _handler = new HttpClientHandler(); _handler.AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip; _client = new HttpClient(_handler, false); _client.BaseAddress = endpoint; _seriesMetaCache = new Dictionary <DatabaseMeasurementInfoKey, DatabaseMeasurementInfo>(); DefaultWriteOptions = new InfluxWriteOptions(); DefaultQueryOptions = new InfluxQueryOptions(); if (!string.IsNullOrEmpty(username) && !string.IsNullOrEmpty(password)) { var encoding = Encoding.GetEncoding("ISO-8859-1"); var credentials = username + ":" + password; var encodedCredentialBytes = encoding.GetBytes(credentials); var encodedCredentials = Convert.ToBase64String(encodedCredentialBytes); _client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", encodedCredentials); } }
private async Task <InfluxResultSet <TInfluxRow> > ExecuteQueryInternalAsync <TInfluxRow>(string query, string db, bool isTimeSeriesQuery, bool forcePost, object parameters, InfluxQueryOptions options) where TInfluxRow : new() { List <QueryResult> queryResults = await PerformQueryInternal(query, db, forcePost, isTimeSeriesQuery, false, parameters, options).ConfigureAwait(false); return(await ResultSetFactory.CreateAsync <TInfluxRow>(this, queryResults, db, isTimeSeriesQuery, options).ConfigureAwait(false)); }
private async Task <InfluxChunkedResultSet <TInfluxRow> > ExecuteQueryByObjectIteratorInternalAsync <TInfluxRow>(string query, string db, bool isTimeSeriesQuery, bool forcePost, object parameters, InfluxQueryOptions options) where TInfluxRow : new() { var iterator = await PerformQueryInternal <TInfluxRow>(query, db, forcePost, isTimeSeriesQuery, true, parameters, options).ConfigureAwait(false); return(new InfluxChunkedResultSet <TInfluxRow>(iterator, this, options, db)); }
private string CreateQueryUrl(string commandOrQuery, string db, bool isTimeSeriesQuery, bool requireChunking, object parameters, InfluxQueryOptions options) { var query = "query"; char seperator = '?'; if (!string.IsNullOrEmpty(db)) { query += $"{seperator}db={UriHelper.SafeEscapeDataString(db)}"; seperator = '&'; } if (!string.IsNullOrEmpty(commandOrQuery)) { query += $"{seperator}q={UriHelper.SafeEscapeDataString(commandOrQuery)}"; seperator = '&'; } if (parameters != null) { query += $"{seperator}params={UriHelper.SafeEscapeDataString(ParamsConverter.GetParams(parameters))}"; seperator = '&'; } if (options != null) { if (options.Precision.HasValue && isTimeSeriesQuery) { query += $"{seperator}epoch={options.Precision.Value.GetQueryParameter()}"; seperator = '&'; } if (options.ChunkSize.HasValue) { query += $"{seperator}chunked=true&chunk_size={options.ChunkSize.Value}"; seperator = '&'; } } // add chunking if it is not already set if (requireChunking && options?.ChunkSize.HasValue != true) { query += $"{seperator}chunked=true"; } return(new Uri(_endpoint, query).ToString()); }
private LongFormUrlEncodedContent CreateQueryPostContent(string commandOrQuery, string db, bool isTimeSeriesQuery, bool requireChunking, object parameters, InfluxQueryOptions options) { List <KeyValuePair <string, string> > param = new List <KeyValuePair <string, string> >(5); if (!string.IsNullOrEmpty(db)) { param.Add(new KeyValuePair <string, string>("db", db)); } if (!string.IsNullOrEmpty(commandOrQuery)) { param.Add(new KeyValuePair <string, string>("q", commandOrQuery)); } if (parameters != null) { param.Add(new KeyValuePair <string, string>("params", ParamsConverter.GetParams(parameters))); } if (options != null) { if (options.Precision.HasValue && isTimeSeriesQuery) { param.Add(new KeyValuePair <string, string>("epoch", options.Precision.Value.GetQueryParameter())); } if (options.ChunkSize.HasValue) { param.Add(new KeyValuePair <string, string>("chunked", "true")); param.Add(new KeyValuePair <string, string>("chunk_size", options.ChunkSize.Value.ToString(CultureInfo.InvariantCulture))); } } // add chunking if it is not already set if (requireChunking && options?.ChunkSize.HasValue != true) { param.Add(new KeyValuePair <string, string>("chunked", "true")); } return(new LongFormUrlEncodedContent(param)); }
/// <summary> /// Executes the query and returns the result with the specified query options. /// </summary> /// <typeparam name="TInfluxRow">The type of the influx row.</typeparam> /// <param name="db">The database.</param> /// <param name="query">The query.</param> /// <param name="parameters">The parameters.</param> /// <param name="options">The options.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns></returns> public Task <InfluxResultSet <TInfluxRow> > ReadAsync <TInfluxRow>(string db, string query, object parameters, InfluxQueryOptions options, CancellationToken cancellationToken = default) where TInfluxRow : new() { return(ExecuteQueryInternalAsync <TInfluxRow>(query, db, true, false, parameters, options, cancellationToken)); }
private async Task <List <QueryResult> > PerformQueryInternal(string query, string db, bool forcePost, bool isTimeSeriesQuery, bool requireChunking, object parameters, InfluxQueryOptions options) { List <QueryResult> queryResults; if (options.UsePost) { queryResults = await ExecuteHttpAsync(HttpMethod.Post, new Uri(_endpoint, "query").ToString(), CreateQueryPostContent(query, db, isTimeSeriesQuery, requireChunking, parameters, options)).ConfigureAwait(false); } else { if (forcePost) { queryResults = await ExecuteHttpAsync(HttpMethod.Post, CreateQueryUrl(query, db, isTimeSeriesQuery, requireChunking, parameters, options)).ConfigureAwait(false); } else { queryResults = await ExecuteHttpAsync(HttpMethod.Get, CreateQueryUrl(query, db, isTimeSeriesQuery, requireChunking, parameters, options)).ConfigureAwait(false); } } return(queryResults); }
/// <summary> /// Executes the query and returns the result with the specified query options. /// </summary> /// <typeparam name="TInfluxRow"></typeparam> /// <param name="query"></param> /// <param name="db"></param> /// <param name="options"></param> /// <returns></returns> public Task <InfluxResultSet <TInfluxRow> > ReadAsync <TInfluxRow>(string db, string query, InfluxQueryOptions options) where TInfluxRow : new() { return(ExecuteQueryInternalAsync <TInfluxRow>(query, db, options)); }
internal InfluxChunkedResultSet(ContextualQueryResultIterator <TInfluxRow> contextualIterator, InfluxClient client, InfluxQueryOptions options, string db) { _iterator = contextualIterator; }
/// <summary> /// Executes the query and returns a deferred result that can be iterated over as they /// are returned by the database. /// /// It does not make sense to use this method unless you are returning a big payload and /// have enabled chunking through InfluxQueryOptions. /// </summary> /// <typeparam name="TInfluxRow"></typeparam> /// <param name="client">The IInfluxClient that performs operation.</param> /// <param name="db"></param> /// <param name="query"></param> /// <param name="options"></param> /// <returns></returns> public static Task <InfluxChunkedResultSet <TInfluxRow> > ReadChunkedAsync <TInfluxRow>(this IInfluxClient client, string db, string query, InfluxQueryOptions options) where TInfluxRow : new() { return(client.ReadChunkedAsync <TInfluxRow>(db, query, null, options)); }
private async Task <InfluxResultSet> ExecuteQueryInternalAsync(string query, string db, bool forcePost, object parameters, InfluxQueryOptions options) { List <QueryResult> queryResults = await PerformQueryInternal(query, db, forcePost, false, false, parameters, options).ConfigureAwait(false); return(ResultSetFactory.Create(queryResults)); }
private async Task <ContextualQueryResultIterator <TInfluxRow> > PerformQueryInternal <TInfluxRow>(string query, string db, bool forcePost, bool isTimeSeriesQuery, bool requireChunking, object parameters, InfluxQueryOptions options) where TInfluxRow : new() { ContextualQueryResultIterator <TInfluxRow> iterator; if (options.UsePost) { iterator = await ExecuteHttpAsync <TInfluxRow>(HttpMethod.Post, new Uri(_endpoint, "query").ToString(), db, options, CreateQueryPostContent(query, db, isTimeSeriesQuery, requireChunking, parameters, options)).ConfigureAwait(false); } else { if (forcePost) { iterator = await ExecuteHttpAsync <TInfluxRow>(HttpMethod.Post, CreateQueryUrl(query, db, isTimeSeriesQuery, requireChunking, parameters, options), db, options).ConfigureAwait(false); } else { iterator = await ExecuteHttpAsync <TInfluxRow>(HttpMethod.Get, CreateQueryUrl(query, db, isTimeSeriesQuery, requireChunking, parameters, options), db, options).ConfigureAwait(false); } } return(iterator); }
private async Task <InfluxResultSet <TInfluxRow> > ExecuteQueryInternalAsync <TInfluxRow>(string query, string db, InfluxQueryOptions options) where TInfluxRow : new() { var queryResult = await GetInternalAsync(CreateQueryUrl( query, db, options ), true).ConfigureAwait(false); return(await ResultSetFactory.CreateAsync <TInfluxRow>(this, queryResult, db, false).ConfigureAwait(false)); }
private async Task <ContextualQueryResultIterator <TInfluxRow> > ExecuteHttpAsync <TInfluxRow>(HttpMethod method, string url, string db, InfluxQueryOptions options, HttpContent content = null) where TInfluxRow : new() { try { using (var request = new HttpRequestMessage(method, url) { Content = (method == HttpMethod.Get ? null : (content == null ? new StringContent("") : content)) }) { request.Headers.Authorization = _authzHeader; var response = await _client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead).ConfigureAwait(false); await EnsureSuccessCode(response).ConfigureAwait(false); var objectIterator = await response.Content.GetObjectIteratorAsync().ConfigureAwait(false); var iterator = new QueryResultIterator <TInfluxRow>(response, objectIterator, this, options, db); var contextualIterator = new ContextualQueryResultIterator <TInfluxRow>(iterator); return(contextualIterator); } } catch (HttpRequestException e) { throw new InfluxException(Errors.UnknownError, e); } }
/// <summary> /// Executes the query and returns a deferred result that can be iterated over as they /// are returned by the database. /// /// It does not make sense to use this method unless you are returning a big payload and /// have enabled chunking through InfluxQueryOptions. /// </summary> /// <typeparam name="TInfluxRow"></typeparam> /// <param name="db"></param> /// <param name="query"></param> /// <param name="options"></param> /// <param name="parameters"></param> /// <returns></returns> public Task <InfluxChunkedResultSet <TInfluxRow> > ReadChunkedAsync <TInfluxRow>(string db, string query, object parameters, InfluxQueryOptions options) where TInfluxRow : new() { return(ExecuteQueryByObjectIteratorInternalAsync <TInfluxRow>(query, db, true, false, parameters, options)); }