示例#1
0
        private void LoadData()
        {
            string result = _etcdClient.GetNodeValueAsync(_path).ConfigureAwait(false).GetAwaiter().GetResult();

            if (string.IsNullOrEmpty(result))
            {
                return;
            }
            Data = ConvertData(result);
        }
示例#2
0
        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));
        }
示例#3
0
        /// <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);
            }
        }
示例#4
0
        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();
                }
            }
        }
示例#5
0
 public T Get(string id)
 {
     return(FromDataRecord(etcdClient.GetNodeValueAsync(CreateKey(id), ignoreKeyNotFoundException: true).Result));
 }
示例#6
0
        // 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);
            });
        }