private void LoadData()
{
string result = _etcdClient.GetNodeValueAsync(_path).ConfigureAwait(false).GetAwaiter().GetResult();
if (string.IsNullOrEmpty(result))
{
return;
}
Data = ConvertData(result);
}
public async Task <IActionResult> Get()
{
// return new string[] { "value1", "value2" };
var __options = new EtcdClientOpitions {
Urls = new string[] { "http://etcd:2379" }
};
EtcdClient etcdClient = new EtcdClient(__options);
await etcdClient.CreateNodeAsync("/key", "my value");
var _value = await etcdClient.GetNodeValueAsync("/key");
return(Ok(_value));
}
/// <summary>
/// 输出在线状态
/// </summary>
/// <returns></returns>
private static async Task OutputOnlineState()
{
try
{
if (m_client != null)
{
//var response = await m_client.GetNodeAsync("/Client");
try
{
EtcdResponse resp1 = await m_client.CreateNodeAsync("/Client", "valye");
EtcdResponse resp = await m_client.SetNodeAsync("/Client", "valye");
Console.WriteLine("Key `{0}` is changed, modifiedIndex={1}", "/Client", resp.Node.ModifiedIndex);
var value = await m_client.GetNodeValueAsync("/Client", true);
Console.WriteLine("The value of `{0}` is `{1}`", "/Client", value);
}
catch (EtcdCommonException.KeyNotFound)
{
Console.WriteLine("Key `{0}` does not exist", "/Client");
}
var response = await m_client.GetNodeAsync("/", true);
if (response != null && response.Node != null)
{
if (response.Node.Nodes != null)
{
foreach (var child in response.Node.Nodes)
{
var key = child.Key.Replace("/Client/", "");
var value = child.Value;
string result = $"{key}状态是{value}";
Console.WriteLine(result);
}
}
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
static async Task DoSample()
{
EtcdClientOpitions options = new EtcdClientOpitions()
{
#if NET45 // TODO: This is optional, having HTTPS setup could make this work in .NET Core as well, but it's not tested for now
Urls = new string[] { "https://etcd0.em", "https://etcd1.em", "https://etcd2.em" },
#else
Urls = new string[] { "http://*****:*****@"client.p12"), // client cerificate
JsonDeserializer = new NewtonsoftJsonDeserializer(),
};
EtcdClient etcdClient = new EtcdClient(options);
string key = "/my/key";
string value;
// query the value of the node using GetNodeValueAsync
try {
value = await etcdClient.GetNodeValueAsync(key);
Console.WriteLine("The value of `{0}` is `{1}`", key, value);
}
catch (EtcdCommonException.KeyNotFound) {
Console.WriteLine("Key `{0}` does not exist", key);
}
// update the value using SetNodeAsync
EtcdResponse resp = await etcdClient.SetNodeAsync(key, "some value");
Console.WriteLine("Key `{0}` is changed, modifiedIndex={1}", key, resp.Node.ModifiedIndex);
// query the node using GetNodeAsync
resp = await etcdClient.GetNodeAsync(key, ignoreKeyNotFoundException : true);
if (resp == null || resp.Node == null)
{
Console.WriteLine("Key `{0}` does not exist", key);
}
else
{
Console.WriteLine("The value of `{0}` is `{1}`", key, resp.Node.Value);
}
//////////////////////////////////////////////////////////
List <Task <EtcdResponse> > tasks = new List <Task <EtcdResponse> >();
key = "/in-order-queue";
// start monitoring the expire event
WatchChanges(etcdClient, key);
// create 5 in-order nodes, TTL = 3 second
for (int i = 0; i < 5; i++)
{
tasks.Add(etcdClient.CreateInOrderNodeAsync(key, i.ToString(), ttl: 3));
}
await Task.WhenAll(tasks);
// list the in-order nodes
resp = await etcdClient.GetNodeAsync(key, false, recursive : true, sorted : true);
if (resp.Node.Nodes != null)
{
foreach (var node in resp.Node.Nodes)
{
Console.WriteLine("`{0}` = {1}", node.Key, node.Value);
}
}
/////////////////////////////////////////////////////////////
key = "/my/cas-test";
value = Guid.NewGuid().ToString();
try {
resp = await etcdClient.CreateNodeAsync(key, value, null, dir : false);
Console.WriteLine("Key `{0}` is created with value {1}", key, value);
}
catch (EtcdCommonException.NodeExist) {
Console.WriteLine("Key `{0}` already exists", key);
}
long prevIndex = 1;
try {
resp = await etcdClient.CompareAndSwapNodeAsync(key, value, "new value");
Console.WriteLine("Key `{0}` is updated to `{1}`", key, resp.Node.Value);
prevIndex = resp.Node.ModifiedIndex;
}
catch (EtcdCommonException.KeyNotFound) {
Console.WriteLine("Key `{0}` does not exists", key);
}
catch (EtcdCommonException.TestFailed) {
Console.WriteLine("Key `{0}` can not be updated because the supplied previous value is incorrect", key);
}
try {
resp = await etcdClient.CompareAndSwapNodeAsync(key, prevIndex, "new value2");
Console.WriteLine("Key `{0}` is updated to `{1}`", key, resp.Node.Value);
}
catch (EtcdCommonException.KeyNotFound) {
Console.WriteLine("Key `{0}` does not exists", key);
}
catch (EtcdCommonException.TestFailed) {
Console.WriteLine("Key `{0}` can not be updated because the supplied previous index is incorrect", key);
}
try {
resp = await etcdClient.CompareAndDeleteNodeAsync(key, prevIndex + 1);
Console.WriteLine("Key `{0}` is deleted", key);
}
catch (EtcdCommonException.KeyNotFound) {
Console.WriteLine("Key `{0}` does not exists", key);
}
catch (EtcdCommonException.TestFailed) {
Console.WriteLine("Key `{0}` can not be deleted because the supplied previous index is incorrect", key);
}
if (prevIndex == 1) // the previous CAS failed
{
try {
resp = await etcdClient.CompareAndDeleteNodeAsync(key, "new value2");
Console.WriteLine("Key `{0}` is deleted", key);
}
catch (EtcdCommonException.KeyNotFound) {
Console.WriteLine("Key `{0}` does not exists", key);
}
catch (EtcdCommonException.TestFailed) {
Console.WriteLine("Key `{0}` can not be deleted because the supplied previous value is incorrect", key);
etcdClient.DeleteNodeAsync(key, ignoreKeyNotFoundException: true).Wait();
}
}
}
public T Get(string id)
{
return(FromDataRecord(etcdClient.GetNodeValueAsync(CreateKey(id), ignoreKeyNotFoundException: true).Result));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var __options = new EtcdClientOpitions {
Urls = new string[] { "http://etcd:2379" }
};
EtcdClient etcdClient = new EtcdClient(__options);
// This adds HealthCheck for app
services.AddHealthChecks(checks =>
{
checks.AddHealthCheckGroup(
"memory",
group => group.AddPrivateMemorySizeCheck(1)
.AddVirtualMemorySizeCheck(2)
.AddWorkingSetCheck(1),
CheckStatus.Unhealthy);
checks.AddHealthCheckGroup(
"redis",
group => { },
CheckStatus.Unhealthy);
checks.AddHealthCheckGroup(
"etcd",
group => { },
CheckStatus.Unhealthy);
});
// This configuration enables distributed cache via Redis
services.AddDistributedRedisCache(async options =>
{
var _redisConnectionString = await etcdClient.GetNodeValueAsync("redisConnectionString");
options.Configuration = _redisConnectionString;//Configuration.GetConnectionString("RedisConnection");
options.InstanceName = "main";
});
// This configuration enables HTTP Compression with Gzip
services.Configure <GzipCompressionProviderOptions>(options => options.Level = CompressionLevel.Optimal);
services.AddResponseCompression(options =>
{
options.Providers.Add <GzipCompressionProvider>();
options.EnableForHttps = true;
});
services
.AddMvc()
.AddJsonOptions(options =>
{
// This configuration sets optimization for JSON serializing
options.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
options.SerializerSettings.PreserveReferencesHandling = PreserveReferencesHandling.Objects;
options.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
options.SerializerSettings.Formatting = Formatting.None;
})
.SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
// This configuration adds support for API versioning
services
.AddMvcCore()
.AddVersionedApiExplorer(options =>
{
options.GroupNameFormat = "'v'VVV";
options.SubstituteApiVersionInUrl = true;
options.AssumeDefaultVersionWhenUnspecified = true;
});
services.AddApiVersioning(options => options.ReportApiVersions = true);
// This configuration enables Swagger generation
services.AddSwaggerGen(options =>
{
var _provider = services.BuildServiceProvider().GetRequiredService <IApiVersionDescriptionProvider>();
foreach (var _description in _provider.ApiVersionDescriptions)
{
options.SwaggerDocByApiVersion(_description);
}
options.OperationFilter <SwaggerDefaultValues>();
var _xmlDocFileName = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
options.IncludeXmlComments(_xmlDocFileName);
});
}
