protected RiakString UpdateMap(TModel model, UpdateMap.MapOperation mapOperation, bool fetchFirst = false)
        {
            byte[] context = null;

            if (fetchFirst)
            {
                MapResponse response = FetchMap(model);
                context = response.Context;
            }

            var builder = new UpdateMap.Builder(mapOperation)
                          .WithBucketType(BucketType)
                          .WithBucket(Bucket);

            if (!string.IsNullOrEmpty(model.ID))
            {
                builder.WithKey(model.ID);
            }

            UpdateMap  cmd  = builder.Build();
            RiakResult rslt = client.Execute(cmd);

            CheckResult(rslt);
            return(cmd.Response.Key);
        }
        private MapResponse SaveMap(UpdateMap.Builder builder)
        {
            UpdateMap  cmd  = builder.Build();
            RiakResult rslt = client.Execute(cmd);

            CheckResult(rslt);

            MapResponse response = cmd.Response;

            PrintObject(response.Value);
            return(response);
        }
Esempio n. 3
0
        private MapResponse SaveMap(string key = null)
        {
            var mapOp = new UpdateMap.MapOperation();

            mapOp.IncrementCounter("counter_1", 1)
            .AddToSet("set_1", "value_1")
            .SetRegister("register_1", "register_value_1")
            .SetFlag("flag_1", true);

            var map_2 = mapOp.Map("map_2");

            map_2.IncrementCounter("counter_1", 2)
            .AddToSet("set_1", "value_1")
            .SetRegister("register_1", "register_value_1")
            .SetFlag("flag_1", true);

            var map_3 = map_2.Map("map_3");

            map_3.IncrementCounter("counter_1", 3);

            var updateBuilder = new UpdateMap.Builder(mapOp)
                                .WithBucketType(BucketType)
                                .WithBucket(Bucket)
                                .WithReturnBody(true)
                                .WithTimeout(TimeSpan.FromMilliseconds(20000));

            if (!string.IsNullOrEmpty(key))
            {
                updateBuilder.WithKey(key);
            }

            UpdateMap  cmd  = updateBuilder.Build();
            RiakResult rslt = client.Execute(cmd);

            Assert.IsTrue(rslt.IsSuccess, rslt.ErrorMessage);

            MapResponse response = cmd.Response;

            Keys.Add(response.Key);

            Assert.True(EnumerableUtil.NotNullOrEmpty(response.Context));

            return(response);
        }
        private MapResponse SaveMap(string key = null)
        {
            var mapOp = new UpdateMap.MapOperation();
            mapOp.IncrementCounter("counter_1", 1)
                .AddToSet("set_1", "value_1")
                .SetRegister("register_1", "register_value_1")
                .SetFlag("flag_1", true);

            var map_2 = mapOp.Map("map_2");
            map_2.IncrementCounter("counter_1", 2)
                .AddToSet("set_1", "value_1")
                .SetRegister("register_1", "register_value_1")
                .SetFlag("flag_1", true);

            var map_3 = map_2.Map("map_3");
            map_3.IncrementCounter("counter_1", 3);

            var updateBuilder = new UpdateMap.Builder(mapOp)
                .WithBucketType(BucketType)
                .WithBucket(Bucket)
                .WithReturnBody(true)
                .WithTimeout(TimeSpan.FromMilliseconds(20000));

            if (!string.IsNullOrEmpty(key))
            {
                updateBuilder.WithKey(key);
            }

            UpdateMap cmd = updateBuilder.Build();
            RiakResult rslt = client.Execute(cmd);
            Assert.IsTrue(rslt.IsSuccess, rslt.ErrorMessage);

            MapResponse response = cmd.Response;
            Keys.Add(response.Key);

            Assert.True(EnumerableUtil.NotNullOrEmpty(response.Context));

            return response;
        }
Esempio n. 5
0
        public void Should_Build_DtUpdateReq_Correctly()
        {
            var mapOp = new UpdateMap.MapOperation()
                .IncrementCounter("counter_1", 50)
                .RemoveCounter("counter_2")
                .AddToSet("set_1", "set_value_1")
                .RemoveFromSet("set_2", "set_value_2")
                .RemoveSet("set_3")
                .SetRegister("register_1", "register_value_1")
                .RemoveRegister("register_2")
                .SetFlag("flag_1", true)
                .RemoveFlag("flag_2")
                .RemoveMap("map_3");

            mapOp.Map("map_2").IncrementCounter("counter_1", 50)
                .RemoveCounter("counter_2")
                .AddToSet("set_1", "set_value_1")
                .RemoveFromSet("set_2", "set_value_2")
                .RemoveSet("set_3")
                .SetRegister("register_1", "register_value_1")
                .RemoveRegister("register_2")
                .SetFlag("flag_1", true)
                .RemoveFlag("flag_2")
                .RemoveMap("map_3");

            var updateMapCommandBuilder = new UpdateMap.Builder(mapOp);

            var q1 = new Quorum(1);
            var q2 = new Quorum(2);
            var q3 = new Quorum(3);

            updateMapCommandBuilder
                .WithBucketType(BucketType)
                .WithBucket(Bucket)
                .WithKey(Key)
                .WithContext(Context)
                .WithW(q3)
                .WithPW(q1)
                .WithDW(q2)
                .WithReturnBody(true)
                .WithIncludeContext(false)
                .WithTimeout(TimeSpan.FromSeconds(20));

            UpdateMap updateMapCommand = updateMapCommandBuilder.Build();

            DtUpdateReq protobuf = (DtUpdateReq)updateMapCommand.ConstructRequest(false);

            Assert.AreEqual(Encoding.UTF8.GetBytes(BucketType), protobuf.type);
            Assert.AreEqual(Encoding.UTF8.GetBytes(Bucket), protobuf.bucket);
            Assert.AreEqual(Encoding.UTF8.GetBytes(Key), protobuf.key);
            Assert.AreEqual((uint)q3, protobuf.w);
            Assert.AreEqual((uint)q1, protobuf.pw);
            Assert.AreEqual((uint)q2, protobuf.dw);
            Assert.IsTrue(protobuf.return_body);
            Assert.IsFalse(protobuf.include_context);
            Assert.AreEqual(20000, protobuf.timeout);
            Assert.AreEqual(Context, protobuf.context);

            MapOp mapOpMsg = protobuf.op.map_op;

            VerifyRemoves(mapOpMsg.removes);
            MapUpdate innerMapUpdate = VerifyUpdates(mapOpMsg.updates, true);
            VerifyRemoves(innerMapUpdate.map_op.removes);
            VerifyUpdates(innerMapUpdate.map_op.updates, false);
        }
        public void Should_Build_DtUpdateReq_Correctly()
        {
            var mapOp = new UpdateMap.MapOperation()
                        .IncrementCounter("counter_1", 50)
                        .RemoveCounter("counter_2")
                        .AddToSet("set_1", "set_value_1")
                        .RemoveFromSet("set_2", "set_value_2")
                        .RemoveSet("set_3")
                        .SetRegister("register_1", "register_value_1")
                        .RemoveRegister("register_2")
                        .SetFlag("flag_1", true)
                        .RemoveFlag("flag_2")
                        .RemoveMap("map_3");

            mapOp.Map("map_2").IncrementCounter("counter_1", 50)
            .RemoveCounter("counter_2")
            .AddToSet("set_1", "set_value_1")
            .RemoveFromSet("set_2", "set_value_2")
            .RemoveSet("set_3")
            .SetRegister("register_1", "register_value_1")
            .RemoveRegister("register_2")
            .SetFlag("flag_1", true)
            .RemoveFlag("flag_2")
            .RemoveMap("map_3");

            var updateMapCommandBuilder = new UpdateMap.Builder(mapOp);

            var q1 = new Quorum(1);
            var q2 = new Quorum(2);
            var q3 = new Quorum(3);

            updateMapCommandBuilder
            .WithBucketType(BucketType)
            .WithBucket(Bucket)
            .WithKey(Key)
            .WithContext(Context)
            .WithW(q3)
            .WithPW(q1)
            .WithDW(q2)
            .WithReturnBody(true)
            .WithIncludeContext(false)
            .WithTimeout(TimeSpan.FromSeconds(20));

            UpdateMap updateMapCommand = updateMapCommandBuilder.Build();

            DtUpdateReq protobuf = (DtUpdateReq)updateMapCommand.ConstructRequest(false);

            Assert.AreEqual(Encoding.UTF8.GetBytes(BucketType), protobuf.type);
            Assert.AreEqual(Encoding.UTF8.GetBytes(Bucket), protobuf.bucket);
            Assert.AreEqual(Encoding.UTF8.GetBytes(Key), protobuf.key);
            Assert.AreEqual((uint)q3, protobuf.w);
            Assert.AreEqual((uint)q1, protobuf.pw);
            Assert.AreEqual((uint)q2, protobuf.dw);
            Assert.IsTrue(protobuf.return_body);
            Assert.IsFalse(protobuf.include_context);
            Assert.AreEqual(20000, protobuf.timeout);
            Assert.AreEqual(Context, protobuf.context);

            MapOp mapOpMsg = protobuf.op.map_op;

            VerifyRemoves(mapOpMsg.removes);
            MapUpdate innerMapUpdate = VerifyUpdates(mapOpMsg.updates, true);

            VerifyRemoves(innerMapUpdate.map_op.removes);
            VerifyUpdates(innerMapUpdate.map_op.updates, false);
        }