public new async Task SetUp()
{
_organization = await FindMyOrg();
var retention = new BucketRetentionRules(BucketRetentionRules.TypeEnum.Expire, 3600);
_bucket = await Client.GetBucketsApi()
.CreateBucketAsync(GenerateName("h2o"), retention, _organization);
//
// Add Permissions to read and write to the Bucket
//
var resource =
new PermissionResource(PermissionResource.TypeEnum.Buckets, _bucket.Id, null, _organization.Id);
var readBucket = new Permission(Permission.ActionEnum.Read, resource);
var writeBucket = new Permission(Permission.ActionEnum.Write, resource);
var loggedUser = await Client.GetUsersApi().MeAsync();
Assert.IsNotNull(loggedUser);
var authorization = await Client.GetAuthorizationsApi()
.CreateAuthorizationAsync(await FindMyOrg(), new List <Permission> {
readBucket, writeBucket
});
_token = authorization.Token;
Client.Dispose();
var options = new InfluxDBClientOptions.Builder().Url(InfluxDbUrl).AuthenticateToken(_token.ToCharArray())
.Org(_organization.Id).Bucket(_bucket.Id).Build();
Client = InfluxDBClientFactory.Create(options);
}
public void SetUp()
{
var options = new InfluxDBClientOptions.Builder()
.Url("http://localhost:8086")
.AuthenticateToken("my-token".ToCharArray())
.Build();
_apiClient = new ApiClient(options, new LoggingHandler(LogLevel.Body), new GzipHandler());
}
public void InitQueryApi()
{
var options = new InfluxDBClientOptions.Builder()
.Url("http://localhost:8086")
.AuthenticateToken("my-token")
.Build();
var queryService = new Mock <QueryService>("http://localhost:8086/api/v2");
_queryApi = new Mock <QueryApiSync>(options, queryService.Object, new FluxResultMapper()).Object;
}
private void WriteData()
{
Environment.SetEnvironmentVariable("point-datacenter", "LA");
ConfigurationManager.AppSettings["point-sensor.version"] = "1.23a";
var options = new InfluxDBClientOptions.Builder().Url(InfluxDbUrl)
.AuthenticateToken(_token)
.AddDefaultTag("id", "132-987-655")
.AddDefaultTag("customer", "California Miner")
.AddDefaultTag("env-var", "${env.point-datacenter}")
.AddDefaultTag("sensor-version", "${point-sensor.version}")
.Build();
Client = InfluxDBClientFactory.Create(options);
var point = PointData.Measurement("h2o_feet").Tag("location", "east").Field("water_level", 1);
var point2 = PointData.Measurement("h2o_feet").Tag("location", "west").Field("water_level", 2);
var point3 = PointData.Measurement("h2o_feet").Tag("location", "west").Field("water_level", 3);
var point4 = PointData.Measurement("h2o_feet").Tag("location", "west").Field("water_level", 4);
var point5 = PointData.Measurement("h2o_feet").Tag("location", "west").Field("water_level", 5);
var point6 = PointData.Measurement("h2o_feet").Tag("location", "west").Field("water_level", 6);
_writeApi = Client.GetWriteApi();
var listener = new WriteApiTest.EventListener(_writeApi);
_writeApi.WritePoint(_bucket.Name, _organization.Id, point);
_writeApi.Flush();
listener.WaitToSuccess();
_writeApi.WritePoint(_bucket.Name, _organization.Id, point2);
_writeApi.Flush();
listener.WaitToSuccess();
_writeApi.WritePoint(_bucket.Name, _organization.Id, point3);
_writeApi.Flush();
listener.WaitToSuccess();
_writeApi.WritePoint(_bucket.Name, _organization.Id, point4);
_writeApi.Flush();
listener.WaitToSuccess();
_writeApi.WritePoint(_bucket.Name, _organization.Id, point5);
_writeApi.Flush();
listener.WaitToSuccess();
_writeApi.WritePoint(_bucket.Name, _organization.Id, point6);
_writeApi.Flush();
listener.WaitToSuccess();
}
public async void CanInsertIntoInflux2()
{
var testContainersBuilder = new TestcontainersBuilder <TestcontainersContainer>()
.WithDockerEndpoint(DockerUtils.DockerEndpoint())
.WithImage("influxdb:2.0-alpine")
.WithEnvironment("DOCKER_INFLUXDB_INIT_MODE", "setup")
.WithEnvironment("DOCKER_INFLUXDB_INIT_USERNAME", "my-user")
.WithEnvironment("DOCKER_INFLUXDB_INIT_PASSWORD", "my-password")
.WithEnvironment("DOCKER_INFLUXDB_INIT_BUCKET", "mydb")
.WithEnvironment("DOCKER_INFLUXDB_INIT_ORG", "myorg")
.WithPortBinding(8086, assignRandomHostPort: true)
.WithWaitStrategy(Wait.ForUnixContainer().UntilPortIsAvailable(8086));
await using var container = testContainersBuilder.Build();
await container.StartAsync();
var baseUrl = $"http://{container.Hostname}:{container.GetMappedPublicPort(8086)}";
var options = new InfluxDBClientOptions.Builder()
.Url(baseUrl)
.Authenticate("my-user", "my-password".ToCharArray())
.Bucket("mydb")
.Org("myorg")
.Build();
var config = new Influx2Config(options);
using var writer = new Influx2Writer(config, "my-pc");
for (int attempts = 0;; attempts++)
{
try
{
await writer.ReportMetrics(DateTime.Now, TestSensorCreator.Values());
var influxDBClient = InfluxDBClientFactory.Create(options);
var flux = "from(bucket:\"mydb\") |> range(start: -1h)";
var queryApi = influxDBClient.GetQueryApi();
var tables = await queryApi.QueryAsync(flux, "myorg");
var fields = tables.SelectMany(x => x.Records).Select(x => x.GetValueByKey("identifier"));
Assert.Contains("/intelcpu/0/temperature/0", fields);
break;
}
catch (Exception)
{
if (attempts >= 10)
{
throw;
}
Thread.Sleep(TimeSpan.FromSeconds(1));
}
}
}
public void ProxyDefaultConfigured()
{
var webProxy = new WebProxy("my-proxy", 8088);
var options = new InfluxDBClientOptions.Builder()
.Url("http://localhost:8086")
.AuthenticateToken("my-token".ToCharArray())
.Proxy(webProxy)
.Build();
_apiClient = new ApiClient(options, new LoggingHandler(LogLevel.Body), new GzipHandler());
Assert.AreEqual(webProxy, _apiClient.RestClient.Proxy);
}
public void Timeout()
{
var options = new InfluxDBClientOptions.Builder()
.Url("http://localhost:8086")
.AuthenticateToken("my-token".ToCharArray())
.TimeOut(TimeSpan.FromSeconds(20))
.ReadWriteTimeOut(TimeSpan.FromSeconds(30))
.Build();
var client = InfluxDBClientFactory.Create(options);
var apiClient = GetDeclaredField <ApiClient>(client.GetType(), client, "_apiClient");
Assert.AreEqual(20_000, apiClient.Configuration.Timeout);
Assert.AreEqual(30_000, apiClient.Configuration.ReadWriteTimeout);
}
public async Task DefaultTagsMeasurement()
{
Client.Dispose();
Environment.SetEnvironmentVariable("measurement-datacenter", "LA");
ConfigurationManager.AppSettings["measurement-sensor.version"] = "1.23a";
var options = new InfluxDBClientOptions.Builder().Url(InfluxDbUrl)
.AuthenticateToken(_token.ToCharArray())
.AddDefaultTag("id", "132-987-655")
.AddDefaultTag("customer", "California Miner")
.AddDefaultTag("env-var", "${env.measurement-datacenter}")
.AddDefaultTag("sensor-version", "${measurement-sensor.version}")
.Build();
Client = InfluxDBClientFactory.Create(options);
var measurement1 = new H20Measurement
{
Location = "coyote_creek", Level = 2.927, Time = DateTime.UtcNow
};
_writeApi = Client.GetWriteApi();
var listener = new WriteApiTest.EventListener(_writeApi);
_writeApi.WriteMeasurement(_bucket.Name, _organization.Id, WritePrecision.Ms, measurement1);
_writeApi.Flush();
listener.WaitToSuccess();
_queryApi = Client.GetQueryApi();
var tables = await _queryApi.QueryAsync(
"from(bucket:\"" + _bucket.Name +
"\") |> range(start: 1970-01-01T00:00:00.000000001Z) |> pivot(rowKey:[\"_time\"], columnKey: [\"_field\"], valueColumn: \"_value\")",
_organization.Id);
Assert.AreEqual(1, tables.Count);
Assert.AreEqual(1, tables[0].Records.Count);
Assert.AreEqual("h2o", tables[0].Records[0].GetMeasurement());
Assert.AreEqual(2.927, tables[0].Records[0].GetValueByKey("level"));
Assert.AreEqual("coyote_creek", tables[0].Records[0].GetValueByKey("location"));
Assert.AreEqual("132-987-655", tables[0].Records[0].GetValueByKey("id"));
Assert.AreEqual("California Miner", tables[0].Records[0].GetValueByKey("customer"));
Assert.AreEqual("1.23a", tables[0].Records[0].GetValueByKey("sensor-version"));
Assert.AreEqual("LA", tables[0].Records[0].GetValueByKey("env-var"));
}
public static Influx2Config ParseAppSettings(IAppConfig config)
{
var builder = new InfluxDBClientOptions.Builder();
string influxAddress = config["influx2_address"];
if (!Uri.TryCreate(influxAddress, UriKind.Absolute, out var addr))
{
throw new ApplicationException($"Unable to parse {influxAddress} into a Uri");
}
builder.Url(influxAddress);
var token = config["influx2_token"];
var user = config["influx2_user"];
var password = config["influx2_password"];
if (!string.IsNullOrEmpty(token))
{
builder.AuthenticateToken(token);
}
else
{
builder.Authenticate(user, password.ToCharArray());
}
var bucket = config["influx2_bucket"];
if (string.IsNullOrEmpty(bucket))
{
throw new ApplicationException($"influx2 needs a bucket to be configured");
}
builder.Bucket(bucket);
var org = config["influx2_org"];
if (string.IsNullOrEmpty(org))
{
throw new ApplicationException($"influx2 needs an org to be configured");
}
builder.Org(org);
return(new Influx2Config(builder.Build()));
}
public async Task DefaultTagsPoint()
{
Client.Dispose();
Environment.SetEnvironmentVariable("point-datacenter", "LA");
ConfigurationManager.AppSettings["point-sensor.version"] = "1.23a";
var options = new InfluxDBClientOptions.Builder().Url(InfluxDbUrl)
.AuthenticateToken(_token)
.AddDefaultTag("id", "132-987-655")
.AddDefaultTag("customer", "California Miner")
.AddDefaultTag("env-var", "${env.point-datacenter}")
.AddDefaultTag("sensor-version", "${point-sensor.version}")
.Build();
Client = InfluxDBClientFactory.Create(options);
var point = PointData.Measurement("h2o_feet").Tag("location", "west").Field("water_level", 1);
_writeApi = Client.GetWriteApi();
var listener = new WriteApiTest.EventListener(_writeApi);
_writeApi.WritePoint(_bucket.Name, _organization.Id, point);
_writeApi.Flush();
listener.WaitToSuccess();
_queryApi = Client.GetQueryApi();
var tables = await _queryApi.QueryAsync(
$"from(bucket:\"{_bucket.Name}\") |> range(start: 1970-01-01T00:00:00.000000001Z) |> pivot(rowKey:[\"_time\"], columnKey: [\"_field\"], valueColumn: \"_value\")",
_organization.Id);
Assert.AreEqual(1, tables.Count);
Assert.AreEqual(1, tables[0].Records.Count);
Assert.AreEqual("h2o_feet", tables[0].Records[0].GetMeasurement());
Assert.AreEqual(1, tables[0].Records[0].GetValueByKey("water_level"));
Assert.AreEqual("west", tables[0].Records[0].GetValueByKey("location"));
Assert.AreEqual("132-987-655", tables[0].Records[0].GetValueByKey("id"));
Assert.AreEqual("California Miner", tables[0].Records[0].GetValueByKey("customer"));
Assert.AreEqual("1.23a", tables[0].Records[0].GetValueByKey("sensor-version"));
Assert.AreEqual("LA", tables[0].Records[0].GetValueByKey("env-var"));
}
public async Task DefaultTagsConfiguration()
{
Client.Dispose();
var options = new InfluxDBClientOptions.Builder()
.LoadConfig()
.Url(InfluxDbUrl)
.AuthenticateToken(_token)
.Build();
Client = InfluxDBClientFactory.Create(options);
var measurement1 = new H20Measurement
{
Location = "coyote_creek", Level = 2.927, Time = DateTime.UtcNow
};
_writeApi = Client.GetWriteApi();
var listener = new WriteApiTest.EventListener(_writeApi);
_writeApi.WriteMeasurement(_bucket.Name, _organization.Id, WritePrecision.Ms, measurement1);
_writeApi.Flush();
listener.WaitToSuccess();
_queryApi = Client.GetQueryApi();
var tables = await _queryApi.QueryAsync(
$"from(bucket:\"{_bucket.Name}\") |> range(start: 1970-01-01T00:00:00.000000001Z) |> pivot(rowKey:[\"_time\"], columnKey: [\"_field\"], valueColumn: \"_value\")",
_organization.Id);
Assert.AreEqual(1, tables.Count);
Assert.AreEqual(1, tables[0].Records.Count);
Assert.AreEqual("h2o", tables[0].Records[0].GetMeasurement());
Assert.AreEqual(2.927, tables[0].Records[0].GetValueByKey("level"));
Assert.AreEqual("coyote_creek", tables[0].Records[0].GetValueByKey("location"));
Assert.AreEqual("132-987-655", tables[0].Records[0].GetValueByKey("id"));
Assert.AreEqual("California Miner", tables[0].Records[0].GetValueByKey("customer"));
Assert.AreEqual("v1.00", tables[0].Records[0].GetValueByKey("version"));
}
public void Race()
{
var options = new InfluxDBClientOptions.Builder().Url(InfluxDbUrl)
.LoadConfig()
.Url(InfluxDbUrl)
.AuthenticateToken(_token.ToCharArray())
.Build();
var point = PointData.Measurement("race-test")
.Tag("test", "stress")
.Field("value", 1);
const int RANGE = 1000;
using (var gateStart = new ManualResetEventSlim(false))
using (var gate = new CountdownEvent(RANGE))
using (var gateEnd = new CountdownEvent(RANGE))
{
for (int i = 0; i < RANGE; i++)
{
var trd = new Thread(() =>
{
gateStart.Wait();
using (WriteApi writer = Client.GetWriteApi())
{
writer.WritePoint(point);
gate.Signal();
gate.Wait();
}
gateEnd.Signal();
});
trd.Start();
}
gateStart.Set();
gateEnd.Wait();
}
}
public static void Main(string[] args)
{
const string host = "https://us-west-2-1.aws.cloud2.influxdata.com";
const string token = "...";
const string bucket = "linq_bucket";
const string organization = "jakub_bednar";
var options = new InfluxDBClientOptions.Builder()
.Url(host)
.AuthenticateToken(token.ToCharArray())
.Org(organization)
.Bucket(bucket)
.Build();
var converter = new DomainEntityConverter();
var client = InfluxDBClientFactory.Create(options)
.EnableGzip();
//
// Query Data to Domain object
//
var queryApi = client.GetQueryApiSync(converter);
var stopWatch = new Stopwatch();
stopWatch.Start();
//
// Select Cloud
//
var query = from s in InfluxDBQueryable <DomainEntity> .Queryable(bucket, organization, queryApi, converter)
select s;
var entities = query.ToList();
Console.WriteLine("==== Cloud Query Results ====");
Console.WriteLine($"> count: {entities.Count}");
Console.WriteLine($"> first: {entities.First()}");
Console.WriteLine($"> elapsed seconds: {stopWatch.Elapsed.TotalSeconds}");
Console.WriteLine();
//
// Debug Query
//
Console.WriteLine("==== Debug LINQ Queryable Flux output ====");
var influxQuery = ((InfluxDBQueryable <DomainEntity>)query).ToDebugQuery();
Console.WriteLine("> variables:");
foreach (var statement in influxQuery.Extern.Body)
{
var os = statement as OptionStatement;
var va = os?.Assignment as VariableAssignment;
var name = va?.Id.Name;
var value = va?.Init.GetType().GetProperty("Value")?.GetValue(va.Init, null);
Console.WriteLine($"{name}={value}");
}
Console.WriteLine();
Console.WriteLine("> query:");
Console.WriteLine(influxQuery._Query);
client.Dispose();
}
public static async Task Main(string[] args)
{
const string host = "http://localhost:9999";
const string token = "my-token";
const string bucket = "my-bucket";
const string organization = "my-org";
var options = new InfluxDBClientOptions.Builder()
.Url(host)
.AuthenticateToken(token.ToCharArray())
.Org(organization)
.Bucket(bucket)
.Build();
var converter = new DomainEntityConverter();
var client = InfluxDBClientFactory.Create(options);
//
// Prepare data to write
//
var time = new DateTimeOffset(2020, 11, 15, 8, 20, 15,
new TimeSpan(3, 0, 0));
var entity1 = new Sensor
{
Timestamp = time,
Type = "temperature",
Version = "v0.0.2",
Value = 15
};
var entity2 = new Sensor
{
Timestamp = time.AddHours(1),
Type = "temperature",
Version = "v0.0.2",
Value = 15
};
var entity3 = new Sensor
{
Timestamp = time.AddHours(2),
Type = "humidity",
Version = "v0.13",
Value = 74
};
var entity4 = new Sensor
{
Timestamp = time.AddHours(3),
Type = "humidity",
Version = "v0.13",
Value = 82
};
//
// Write data
//
await client.GetWriteApiAsync(converter)
.WriteMeasurementsAsync(WritePrecision.S, entity1, entity2, entity3, entity4);
//
// Query Data to Domain object
//
var queryApi = client.GetQueryApiSync(converter);
//
// Select ALL
//
var query = $"from(bucket:\"{bucket}\") " +
"|> range(start: 0) " +
"|> filter(fn: (r) => r[\"_measurement\"] == \"sensor\")" +
"|> pivot(rowKey:[\"_time\"], columnKey: [\"_field\"], valueColumn: \"_value\")";
var sensors = queryApi.QuerySync <Sensor>(query);
//
// Print result
//
sensors.ForEach(it => Console.WriteLine(it.ToString()));
client.Dispose();
}
public async Task Delete()
{
Client.Dispose();
Environment.SetEnvironmentVariable("point-datacenter", "LA");
ConfigurationManager.AppSettings["point-sensor.version"] = "1.23a";
var options = new InfluxDBClientOptions.Builder().Url(InfluxDbUrl)
.AuthenticateToken(_token.ToCharArray())
.AddDefaultTag("id", "132-987-655")
.AddDefaultTag("customer", "California Miner")
.AddDefaultTag("env-var", "${env.point-datacenter}")
.AddDefaultTag("sensor-version", "${point-sensor.version}")
.Build();
Client = InfluxDBClientFactory.Create(options);
var point = PointData.Measurement("h2o_feet").Tag("location", "west").Field("water_level", 1);
var point2 = PointData.Measurement("h2o_feet").Tag("location", "west").Field("water_level", 2);
var point3 = PointData.Measurement("h2o_feet").Tag("location", "west").Field("water_level", 3);
var point4 = PointData.Measurement("h2o_feet").Tag("location", "west").Field("water_level", 4);
var point5 = PointData.Measurement("h2o_feet").Tag("location", "west").Field("water_level", 5);
var point6 = PointData.Measurement("h2o_feet").Tag("location", "west").Field("water_level", 6);
_writeApi = Client.GetWriteApi();
var listener = new WriteApiTest.EventListener(_writeApi);
_writeApi.WritePoint(_bucket.Name, _organization.Id, point);
_writeApi.Flush();
listener.WaitToSuccess();
_writeApi.WritePoint(_bucket.Name, _organization.Id, point2);
_writeApi.Flush();
listener.WaitToSuccess();
_writeApi.WritePoint(_bucket.Name, _organization.Id, point3);
_writeApi.Flush();
listener.WaitToSuccess();
_writeApi.WritePoint(_bucket.Name, _organization.Id, point4);
_writeApi.Flush();
listener.WaitToSuccess();
_writeApi.WritePoint(_bucket.Name, _organization.Id, point5);
_writeApi.Flush();
listener.WaitToSuccess();
_writeApi.WritePoint(_bucket.Name, _organization.Id, point6);
_writeApi.Flush();
listener.WaitToSuccess();
string query = "from(bucket:\"" + _bucket.Name +
"\") |> range(start: 1970-01-01T00:00:00.000000001Z) |> pivot(rowKey:[\"_time\"], columnKey: [\"_field\"], valueColumn: \"_value\")";
_queryApi = Client.GetQueryApi();
var tables = await _queryApi.QueryAsync(query, _organization.Id);
Assert.AreEqual(1, tables.Count);
Assert.AreEqual(6, tables[0].Records.Count);
_deleteApi = Client.GetDeleteApi();
await _deleteApi.Delete(DateTime.Now.AddSeconds(-1), DateTime.Now, "", _bucket, _organization);
var tablesAfterDelete = await _queryApi.QueryAsync(query, _organization.Id);
Assert.AreNotEqual(0, tablesAfterDelete.Count);
await _deleteApi.Delete(DateTime.Now.AddHours(-1), DateTime.Now, "", _bucket, _organization);
var tablesAfterDelete2 = await _queryApi.QueryAsync(query, _organization.Id);
Assert.AreEqual(0, tablesAfterDelete2.Count);
}
public static async Task Main(string[] args)
{
const string host = "http://localhost:9999";
const string token = "my-token";
const string bucket = "my-bucket";
const string organization = "my-org";
var options = new InfluxDBClientOptions.Builder()
.Url(host)
.AuthenticateToken(token.ToCharArray())
.Org(organization)
.Bucket(bucket)
.Build();
var converter = new DomainEntityConverter();
var client = InfluxDBClientFactory.Create(options);
//
// Prepare data to write
//
var time = new DateTimeOffset(2020, 11, 15, 8, 20, 15,
new TimeSpan(3, 0, 0));
var entity1 = new DomainEntity
{
Timestamp = time,
SeriesId = Guid.Parse("0f8fad5b-d9cb-469f-a165-70867728950e"),
Value = 15,
Properties = new List <DomainEntityAttribute>
{
new DomainEntityAttribute
{
Name = "height", Value = 4
},
new DomainEntityAttribute
{
Name = "width", Value = 110
}
}
};
var entity2 = new DomainEntity
{
Timestamp = time.AddHours(1),
SeriesId = Guid.Parse("0f8fad5b-d9cb-469f-a165-70867728950e"),
Value = 15,
Properties = new List <DomainEntityAttribute>
{
new DomainEntityAttribute
{
Name = "height", Value = 5
},
new DomainEntityAttribute
{
Name = "width", Value = 160
}
}
};
var entity3 = new DomainEntity
{
Timestamp = time.AddHours(2),
SeriesId = Guid.Parse("7c9e6679-7425-40de-944b-e07fc1f90ae7"),
Value = 15,
Properties = new List <DomainEntityAttribute>
{
new DomainEntityAttribute
{
Name = "height", Value = 5
},
new DomainEntityAttribute
{
Name = "width", Value = 110
}
}
};
var entity4 = new DomainEntity
{
Timestamp = time.AddHours(3),
SeriesId = Guid.Parse("7c9e6679-7425-40de-944b-e07fc1f90ae7"),
Value = 15,
Properties = new List <DomainEntityAttribute>
{
new DomainEntityAttribute
{
Name = "height", Value = 6
},
new DomainEntityAttribute
{
Name = "width", Value = 160
}
}
};
//
// Write data
//
await client.GetWriteApiAsync(converter)
.WriteMeasurementsAsync(WritePrecision.S, entity1, entity2, entity3, entity4);
//
// Query Data to Domain object
//
var queryApi = client.GetQueryApiSync(converter);
//
// Select ALL
//
var query = from s in InfluxDBQueryable <DomainEntity> .Queryable("my-bucket", "my-org", queryApi, converter)
select s;
Console.WriteLine("==== Select ALL ====");
query.ToList().ForEach(it => Console.WriteLine(it.ToString()));
//
// Filter By Tag
//
query = from s in InfluxDBQueryable <DomainEntity> .Queryable("my-bucket", "my-org", queryApi, converter)
where s.SeriesId == Guid.Parse("7c9e6679-7425-40de-944b-e07fc1f90ae7")
select s;
Console.WriteLine("==== Filter by Tag ====");
query.ToList().ForEach(it => Console.WriteLine(it.ToString()));
//
// Use Take + Skip
//
query = (from s in InfluxDBQueryable <DomainEntity> .Queryable("my-bucket", "my-org", queryApi, converter)
select s)
.Take(1)
.Skip(1);
Console.WriteLine("==== Use Take + Skip ====");
query.ToList().ForEach(it => Console.WriteLine(it.ToString()));
//
// Use Time Range
//
query = from s in InfluxDBQueryable <DomainEntity> .Queryable("my-bucket", "my-org", queryApi, converter)
where s.Timestamp > time.AddMinutes(30) && s.Timestamp < time.AddHours(3)
select s;
Console.WriteLine("==== Use Time Range ====");
query.ToList().ForEach(it => Console.WriteLine(it.ToString()));
//
// Use Any
//
query = from s in InfluxDBQueryable <DomainEntity> .Queryable("my-bucket", "my-org", queryApi, converter)
where s.Properties.Any(a => a.Name == "width" && a.Value == 160)
select s;
Console.WriteLine("==== Use Any ====");
query.ToList().ForEach(it => Console.WriteLine(it.ToString()));
//
// Debug Query
//
Console.WriteLine("==== Debug LINQ Queryable Flux output ====");
var influxQuery = ((InfluxDBQueryable <DomainEntity>)query).ToDebugQuery();
foreach (var statement in influxQuery.Extern.Body)
{
var os = statement as OptionStatement;
var va = os?.Assignment as VariableAssignment;
var name = va?.Id.Name;
var value = va?.Init.GetType().GetProperty("Value")?.GetValue(va.Init, null);
Console.WriteLine($"{name}={value}");
}
Console.WriteLine();
Console.WriteLine(influxQuery._Query);
client.Dispose();
}
public static async Task Main(string[] args)
{
//
// Initialize Client
//
const string host = "http://localhost:9999";
const string token = "my-token";
const string bucket = "my-bucket";
const string organization = "my-org";
var options = new InfluxDBClientOptions.Builder()
.Url(host)
.AuthenticateToken(token.ToCharArray())
.Org(organization)
.Bucket(bucket)
.Build();
var client = InfluxDBClientFactory.Create(options);
//
// Prepare data to write
//
var time = new DateTime(2020, 11, 15, 8, 20, 15, DateTimeKind.Utc);
var sensorTime1 = new Sensor
{
Type = "bme280",
Device = "raspberrypi",
Humidity = 54.05,
Pressure = 991.62,
Temperature = 15.22,
Time = time.Subtract(TimeSpan.FromHours(1))
};
var sensorTime2 = new Sensor
{
Type = "bme280",
Device = "raspberrypi",
Humidity = 54.01,
Pressure = 991.56,
Temperature = 17.82,
Time = time
};
//
// Write data
//
await client.GetWriteApiAsync()
.WriteMeasurementsAsync(WritePrecision.S, sensorTime1, sensorTime2);
//
// Query Data to Domain object
//
var query = $"from(bucket:\"{bucket}\") " +
"|> range(start: 0) " +
"|> pivot(rowKey:[\"_time\"], columnKey: [\"_field\"], valueColumn: \"_value\")";
var list = await client.GetQueryApi().QueryAsync <Sensor>(query);
//
// Print result
//
list.ForEach(it => Console.WriteLine(it.ToString()));
client.Dispose();
}
