Example #1
0
        public void UpdateData_should_return_success_if_get_update_set_data_are_successful()
        {
            const string path  = "zk/default";
            var          bytes = new byte[] { 0, 1, 1, 2, 3, 5, 8, 13 };

            zooKeeperClient.GetDataAsync(Arg.Any <GetDataRequest>())
            .Returns(GetDataResult.Successful(path, bytes, Stat));

            zooKeeperClient.SetDataAsync(Arg.Any <SetDataRequest>()).Returns(SetDataResult.Successful(path, Stat));

            zooKeeperClient.UpdateData(new UpdateDataRequest(path, dummyUpdate))
            .Should()
            .BeEquivalentTo(UpdateDataResult.Successful(path));
        }
        /// <summary>
        /// <para>Trying to update node data with optimistic concurrency strategy according to given <paramref name="request"/>.</para>
        /// <para>Check returned <see cref="UpdateDataResult"/> to see if operation was successful.</para>
        /// </summary>
        public static async Task <UpdateDataResult> UpdateDataAsync(this IZooKeeperClient zooKeeperClient, UpdateDataRequest request)
        {
            try
            {
                for (var i = 0; i < request.Attempts; i++)
                {
                    var readResult = await zooKeeperClient.GetDataAsync(new GetDataRequest(request.Path)).ConfigureAwait(false);

                    if (!readResult.IsSuccessful)
                    {
                        return(UpdateDataResult.Unsuccessful(readResult.Status, readResult.Path, readResult.Exception));
                    }

                    var newData = request.Update(readResult.Data);

                    if (ByteArrayKey.Equals(readResult.Data, newData))
                    {
                        return(UpdateDataResult.Successful(readResult.Path));
                    }

                    var setDataRequest = new SetDataRequest(request.Path, newData)
                    {
                        Version = readResult.Stat.Version
                    };

                    var updateResult = await zooKeeperClient.SetDataAsync(setDataRequest).ConfigureAwait(false);

                    if (updateResult.Status == ZooKeeperStatus.VersionsMismatch)
                    {
                        continue;
                    }

                    return(updateResult.IsSuccessful ? UpdateDataResult.Successful(updateResult.Path) : UpdateDataResult.Unsuccessful(updateResult.Status, updateResult.Path, updateResult.Exception));
                }

                return(UpdateDataResult.Unsuccessful(ZooKeeperStatus.VersionsMismatch, request.Path, null));
            }
            catch (Exception e)
            {
                return(UpdateDataResult.Unsuccessful(ZooKeeperStatus.UnknownError, request.Path, e));
            }
        }
Example #3
0
        public void UpdateData_should_not_apply_update_when_bytes_not_changed()
        {
            const string path         = "zk/default";
            const int    attempts     = 10;
            var          bytes        = new byte[] { 0, 1, 1, 2, 3, 5, 8, 13 };
            var          updatedBytes = new byte[] { 0, 1, 1, 2, 3, 5, 8, 13 };

            byte[] UpdateFunc(byte[] oldBytes) =>
            updatedBytes;

            zooKeeperClient.GetDataAsync(Arg.Any <GetDataRequest>())
            .Returns(GetDataResult.Successful(path, bytes, Stat));

            zooKeeperClient.UpdateData(new UpdateDataRequest(path, UpdateFunc)
            {
                Attempts = attempts
            })
            .Should().BeEquivalentTo(UpdateDataResult.Successful(path));

            zooKeeperClient
            .DidNotReceiveWithAnyArgs()
            .SetDataAsync(Arg.Any <SetDataRequest>());
        }