public override string Save(BlogPost model)
        {
            var mapOp = new UpdateMap.MapOperation();

            mapOp.SetRegister(titleRegister, model.Title);
            mapOp.SetRegister(authorRegister, model.Author);
            mapOp.SetRegister(contentRegister, model.Content);
            mapOp.AddToSet(keywordsSet, model.Keywords);

            string datePostedSolrFormatted =
                model.DatePosted
                .ToUniversalTime()
                .ToString("yyyy-MM-dd'T'HH:mm:ss'Z'", CultureInfo.InvariantCulture);

            mapOp.SetRegister(datePostedRegister, datePostedSolrFormatted);

            mapOp.SetFlag(publishedFlag, model.Published);

            // NB: no key so Riak will generate it
            var cmd = new UpdateMap.Builder()
                      .WithBucketType(BucketType)
                      .WithBucket(this.bucket)
                      .WithMapOperation(mapOp)
                      .Build();

            RiakResult rslt = client.Execute(cmd);

            CheckResult(rslt);
            MapResponse response = cmd.Response;

            return(response.Key);
        }
Exemplo n.º 2
0
        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);
        }
Exemplo n.º 3
0
        public void Can_Remove_Data_From_A_Map()
        {
            string      key = Guid.NewGuid().ToString();
            MapResponse r   = SaveMap(key);

            var mapOp = new UpdateMap.MapOperation();

            mapOp.RemoveCounter("counter_1");

            var update = new UpdateMap.Builder(mapOp)
                         .WithBucketType(BucketType)
                         .WithBucket(Bucket)
                         .WithKey(key)
                         .WithContext(r.Context)
                         .WithReturnBody(true)
                         .WithTimeout(TimeSpan.FromMilliseconds(20000))
                         .Build();

            RiakResult rslt = client.Execute(update);

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

            MapResponse response = update.Response;

            Assert.False(response.Value.Counters.ContainsKey("counter_1"));
        }
Exemplo n.º 4
0
        public void RemoveInterest(User model, string interest)
        {
            var mapOperation = new UpdateMap.MapOperation();

            mapOperation.RemoveFromSet(interestsSet, interest);

            // Removing from a set requires context
            UpdateMap(model, mapOperation, fetchFirst: true);
        }
Exemplo n.º 5
0
        public void AddInterest(User model, string interest)
        {
            var mapOperation = new UpdateMap.MapOperation();

            mapOperation.AddToSet(interestsSet, interest);

            // Adding to a set does not require context
            UpdateMap(model, mapOperation, fetchFirst: false);
        }
Exemplo n.º 6
0
        private void SetPaidAccount(User model, bool value)
        {
            var mapOperation = new UpdateMap.MapOperation();

            mapOperation.SetFlag(paidAccountFlag, value);

            // Flag update does not require context
            UpdateMap(model, mapOperation, fetchFirst: false);
        }
Exemplo n.º 7
0
        public void IncrementPageVisits(User model)
        {
            var mapOperation = new UpdateMap.MapOperation();

            mapOperation.IncrementCounter(pageVisitsCounter, 1);

            // Update without context
            UpdateMap(model, mapOperation, fetchFirst: false);
        }
Exemplo n.º 8
0
        public override string Save(User model)
        {
            var mapOperation = new UpdateMap.MapOperation();

            mapOperation.SetRegister(firstNameRegister, model.FirstName);
            mapOperation.SetRegister(lastNameRegister, model.LastName);
            mapOperation.IncrementCounter(pageVisitsCounter, model.PageVisits);
            mapOperation.AddToSet(interestsSet, model.Interests);

            // Insert does not require context
            RiakString key = UpdateMap(model, mapOperation, fetchFirst: false);

            return((string)key);
        }
Exemplo n.º 9
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);
        }
        public void Can_Remove_Data_From_A_Map()
        {
            string key = Guid.NewGuid().ToString();
            MapResponse r = SaveMap(key);

            var mapOp = new UpdateMap.MapOperation();
            mapOp.RemoveCounter("counter_1");

            var update = new UpdateMap.Builder(mapOp)
                .WithBucketType(BucketType)
                .WithBucket(Bucket)
                .WithKey(key)
                .WithContext(r.Context)
                .WithReturnBody(true)
                .WithTimeout(TimeSpan.FromMilliseconds(20000))
                .Build();

            RiakResult rslt = client.Execute(update);
            Assert.IsTrue(rslt.IsSuccess, rslt.ErrorMessage);

            MapResponse response = update.Response;
            Assert.False(response.Value.Counters.ContainsKey("counter_1"));
        }
Exemplo n.º 11
0
        public void Should_Construct_MapResponse_From_DtUpdateResp()
        {
            var key     = new RiakString("riak_generated_key");
            var context = new RiakString("1234");

            var updateResp = new DtUpdateResp();

            updateResp.key     = key;
            updateResp.context = context;

            Func <IEnumerable <MapEntry> > createMapEntries = () =>
            {
                var mapEntries = new List <MapEntry>();

                var mapField = new MapField();
                mapField.type = MapField.MapFieldType.COUNTER;
                mapField.name = new RiakString("counter_1");
                var mapEntry = new MapEntry();
                mapEntry.field         = mapField;
                mapEntry.counter_value = 50;
                mapEntries.Add(mapEntry);

                mapField       = new MapField();
                mapField.type  = MapField.MapFieldType.SET;
                mapField.name  = new RiakString("set_1");
                mapEntry       = new MapEntry();
                mapEntry.field = mapField;
                mapEntry.set_value.Add(RiakString.ToBytes("value_1"));
                mapEntry.set_value.Add(RiakString.ToBytes("value_2"));
                mapEntries.Add(mapEntry);

                mapField                = new MapField();
                mapField.type           = MapField.MapFieldType.REGISTER;
                mapField.name           = new RiakString("register_1");
                mapEntry                = new MapEntry();
                mapEntry.field          = mapField;
                mapEntry.register_value = RiakString.ToBytes("1234");
                mapEntries.Add(mapEntry);

                mapField            = new MapField();
                mapField.type       = MapField.MapFieldType.FLAG;
                mapField.name       = new RiakString("flag_1");
                mapEntry            = new MapEntry();
                mapEntry.field      = mapField;
                mapEntry.flag_value = true;
                mapEntries.Add(mapEntry);

                return(mapEntries);
            };

            updateResp.map_value.AddRange(createMapEntries());

            var map_1_field = new MapField();

            map_1_field.type = MapField.MapFieldType.MAP;
            map_1_field.name = new RiakString("map_1");
            var map_1_entry = new MapEntry();

            map_1_entry.field = map_1_field;
            map_1_entry.map_value.AddRange(createMapEntries());

            updateResp.map_value.Add(map_1_entry);

            Action <Map> verifyMap = (map) =>
            {
                Assert.AreEqual(50, map.Counters["counter_1"]);
                Assert.AreEqual(RiakString.ToBytes("value_1"), map.Sets["set_1"][0]);
                Assert.AreEqual(RiakString.ToBytes("value_2"), map.Sets["set_1"][1]);
                Assert.AreEqual(RiakString.ToBytes("1234"), map.Registers["register_1"]);
                Assert.IsTrue(map.Flags["flag_1"]);
            };

            var mapOp = new UpdateMap.MapOperation();

            var update = new UpdateMap.Builder(mapOp)
                         .WithBucketType("maps")
                         .WithBucket("myBucket")
                         .WithKey("map_1")
                         .Build();

            update.OnSuccess(updateResp);

            MapResponse response = update.Response;

            Assert.NotNull(response);
            Assert.AreEqual(key, response.Key);
            Assert.AreEqual(RiakString.ToBytes(context), response.Context);

            verifyMap(response.Value);
            verifyMap(response.Value.Maps["map_1"]);
        }
        public void Maps()
        {
            const string firstNameRegister = "first_name";
            const string lastNameRegister = "last_name";
            const string enterpriseCustomerFlag = "enterprise_customer";
            const string pageVisitsCounter = "page_visits";
            const string interestsSet = "interests";

            var idrisAdds = new[] { "acting", "being Stringer Bell" };

            var mapOp = new UpdateMap.MapOperation()
                .SetRegister(firstNameRegister, "Idris")
                .SetRegister(lastNameRegister, "Elba")
                .SetFlag(enterpriseCustomerFlag, false)
                .IncrementCounter(pageVisitsCounter, 10)
                .AddToSet(interestsSet, idrisAdds);

            var cmd = new UpdateMap.Builder()
                .WithBucketType("maps")
                .WithBucket("customers")
                .WithKey("idris_elba")
                .WithMapOperation(mapOp)
                .Build();

            RiakResult rslt = client.Execute(cmd);
            CheckResult(rslt);

            var joanJettAdds = new[] { "loving rock and roll", "being in the Blackhearts" };

            mapOp = new UpdateMap.MapOperation()
                .SetRegister(firstNameRegister, "Joan")
                .SetRegister(lastNameRegister, "Jett")
                .SetFlag(enterpriseCustomerFlag, false)
                .IncrementCounter(pageVisitsCounter, 25)
                .AddToSet(interestsSet, joanJettAdds);

            cmd = new UpdateMap.Builder()
                .WithBucketType("maps")
                .WithBucket("customers")
                .WithKey("joan_jett")
                .WithMapOperation(mapOp)
                .Build();

            rslt = client.Execute(cmd);
            CheckResult(rslt);

            WaitForSearch();

            DoSearch("customers", "page_visits_counter:[15 TO *]");

            // Add "alter ego" sub-map
            const string nameRegister = "name";
            const string alterEgoMap = "alter_ego";

            mapOp = new UpdateMap.MapOperation();
            mapOp.Map(alterEgoMap).SetRegister(nameRegister, "John Luther");

            cmd = new UpdateMap.Builder()
                .WithBucketType("maps")
                .WithBucket("customers")
                .WithKey("idris_elba")
                .WithMapOperation(mapOp)
                .Build();

            rslt = client.Execute(cmd);
            CheckResult(rslt);

            PrintObject(cmd.Response.Value);

            WaitForSearch();

            DoSearch("customers", "alter_ego_map.name_register:*");
        }
Exemplo n.º 13
0
        public void Maps()
        {
            var builder = new UpdateMap.Builder()
                          .WithBucketType("maps")
                          .WithBucket("customers")
                          .WithKey("ahmed_info");

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Initial import of Ahmed's data and contact");

            var mapOperation = new UpdateMap.MapOperation();

            // Ahmed's first name
            mapOperation.SetRegister("first_name", "Ahmed");

            // Ahmed's phone number
            mapOperation.SetRegister("phone_number", "5551234567");

            builder.WithMapOperation(mapOperation);
            MapResponse response = SaveMap(builder);

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Set Ahmed to NOT be an enterprise customer right now");

            mapOperation = new UpdateMap.MapOperation();
            mapOperation.SetFlag("enterprise_customer", false);

            builder.WithMapOperation(mapOperation);
            response = SaveMap(builder);

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("enterprise_customer flag value");

            Map ahmedMap = response.Value;

            Console.WriteLine("Ahmed enterprise_customer: {0}", ahmedMap.Flags["enterprise_customer"]);

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Add page visits counter for Ahmed");

            mapOperation = new UpdateMap.MapOperation();
            mapOperation.IncrementCounter("page_visits", 1);

            builder.WithMapOperation(mapOperation);
            response = SaveMap(builder);

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Add Ahmed's interests set");

            var interestsAdds = new[] { "robots", "opera", "motorcycles" };

            mapOperation = new UpdateMap.MapOperation();
            mapOperation.AddToSet("interests", interestsAdds);

            builder.WithMapOperation(mapOperation);
            response = SaveMap(builder);

            ahmedMap = response.Value;

            Assert.True(ahmedMap.Sets.GetValue("interests").Contains("robots"));
            Assert.True(ahmedMap.Sets.GetValue("interests").Contains("opera"));
            Assert.True(ahmedMap.Sets.GetValue("interests").Contains("motorcycles"));

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Updating Ahmed's interests");

            mapOperation = new UpdateMap.MapOperation();
            mapOperation.AddToSet("interests", "indie pop");
            mapOperation.RemoveFromSet("interests", "opera");

            builder
            .WithMapOperation(mapOperation)
            .WithContext(response.Context);
            response = SaveMap(builder);

            ahmedMap = response.Value;

            Assert.False(ahmedMap.Sets.GetValue("interests").Contains("opera"));
            Assert.True(ahmedMap.Sets.GetValue("interests").Contains("indie pop"));

            Assert.True(ahmedMap.Sets.GetValue("interests").Contains("robots"));
            Assert.True(ahmedMap.Sets.GetValue("interests").Contains("motorcycles"));

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Adding Annika map");

            mapOperation = new UpdateMap.MapOperation();

            UpdateMap.MapOperation annikaInfoOperation = mapOperation.Map("annika_info");
            annikaInfoOperation.SetRegister("first_name", "Annika");
            annikaInfoOperation.SetRegister("last_name", "Weiss");
            annikaInfoOperation.SetRegister("phone_number", "5559876543");

            builder.WithMapOperation(mapOperation);
            response = SaveMap(builder);

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Annika's first name");

            ahmedMap = response.Value;
            Console.WriteLine(ahmedMap.Maps["annika_info"].Registers.GetValue("first_name"));

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Removing Annika's first name");

            mapOperation = new UpdateMap.MapOperation();
            mapOperation.Map("annika_info").RemoveRegister("first_name");

            builder
            .WithMapOperation(mapOperation)
            .WithContext(response.Context);
            response = SaveMap(builder);

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Storing Annika's plan flags");

            mapOperation = new UpdateMap.MapOperation();
            mapOperation.Map("annika_info")
            .SetFlag("enterprise_plan", false)
            .SetFlag("family_plan", false)
            .SetFlag("free_plan", true);

            builder.WithMapOperation(mapOperation);
            response = SaveMap(builder);

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Is Annika on enterprise plan?");

            ahmedMap = response.Value;
            Console.WriteLine(ahmedMap.Maps["annika_info"].Flags["enterprise_plan"]);

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Adding Annika's widget_purchases counter");

            mapOperation = new UpdateMap.MapOperation();
            mapOperation.Map("annika_info").IncrementCounter("widget_purchases", 1);

            builder.WithMapOperation(mapOperation);
            response = SaveMap(builder);

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Adding Annika's interests in a set");

            mapOperation = new UpdateMap.MapOperation();
            mapOperation.Map("annika_info").AddToSet("interests", "tango dancing");

            builder.WithMapOperation(mapOperation);
            response = SaveMap(builder);

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Remove \"tango dancing\" from Annika's interests");

            mapOperation = new UpdateMap.MapOperation();
            mapOperation.Map("annika_info").RemoveFromSet("interests", "tango dancing");

            builder
            .WithMapOperation(mapOperation)
            .WithContext(response.Context);
            response = SaveMap(builder);

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Add specific purchase info to Annika's data");

            mapOperation = new UpdateMap.MapOperation();
            mapOperation.Map("annika_info").Map("purchase")
            .SetFlag("first_purchase", true)
            .SetRegister("amount", "1271")
            .AddToSet("items", "large widget");

            builder.WithMapOperation(mapOperation);
            response = SaveMap(builder);

            Console.WriteLine("Context: {0}", Convert.ToBase64String(response.Context));
        }
Exemplo n.º 14
0
        public void Maps()
        {
            const string firstNameRegister      = "first_name";
            const string lastNameRegister       = "last_name";
            const string enterpriseCustomerFlag = "enterprise_customer";
            const string pageVisitsCounter      = "page_visits";
            const string interestsSet           = "interests";

            var idrisAdds = new[] { "acting", "being Stringer Bell" };

            var mapOp = new UpdateMap.MapOperation()
                        .SetRegister(firstNameRegister, "Idris")
                        .SetRegister(lastNameRegister, "Elba")
                        .SetFlag(enterpriseCustomerFlag, false)
                        .IncrementCounter(pageVisitsCounter, 10)
                        .AddToSet(interestsSet, idrisAdds);

            var cmd = new UpdateMap.Builder()
                      .WithBucketType("maps")
                      .WithBucket("customers")
                      .WithKey("idris_elba")
                      .WithMapOperation(mapOp)
                      .Build();

            RiakResult rslt = client.Execute(cmd);

            CheckResult(rslt);

            var joanJettAdds = new[] { "loving rock and roll", "being in the Blackhearts" };

            mapOp = new UpdateMap.MapOperation()
                    .SetRegister(firstNameRegister, "Joan")
                    .SetRegister(lastNameRegister, "Jett")
                    .SetFlag(enterpriseCustomerFlag, false)
                    .IncrementCounter(pageVisitsCounter, 25)
                    .AddToSet(interestsSet, joanJettAdds);

            cmd = new UpdateMap.Builder()
                  .WithBucketType("maps")
                  .WithBucket("customers")
                  .WithKey("joan_jett")
                  .WithMapOperation(mapOp)
                  .Build();

            rslt = client.Execute(cmd);
            CheckResult(rslt);

            WaitForSearch();

            DoSearch("customers", "page_visits_counter:[15 TO *]");

            // Add "alter ego" sub-map
            const string nameRegister = "name";
            const string alterEgoMap  = "alter_ego";

            mapOp = new UpdateMap.MapOperation();
            mapOp.Map(alterEgoMap).SetRegister(nameRegister, "John Luther");

            cmd = new UpdateMap.Builder()
                  .WithBucketType("maps")
                  .WithBucket("customers")
                  .WithKey("idris_elba")
                  .WithMapOperation(mapOp)
                  .Build();

            rslt = client.Execute(cmd);
            CheckResult(rslt);

            PrintObject(cmd.Response.Value);

            WaitForSearch();

            DoSearch("customers", "alter_ego_map.name_register:*");
        }
Exemplo n.º 15
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);
        }
Exemplo n.º 16
0
        public void Should_Construct_MapResponse_From_DtUpdateResp()
        {
            var key = new RiakString("riak_generated_key");
            var context = new RiakString("1234");

            var updateResp = new DtUpdateResp();
            updateResp.key = key;
            updateResp.context = context;

            Func<IEnumerable<MapEntry>> createMapEntries = () =>
            {
                var mapEntries = new List<MapEntry>();

                var mapField = new MapField();
                mapField.type = MapField.MapFieldType.COUNTER;
                mapField.name = new RiakString("counter_1");
                var mapEntry = new MapEntry();
                mapEntry.field = mapField;
                mapEntry.counter_value = 50;
                mapEntries.Add(mapEntry);

                mapField = new MapField();
                mapField.type = MapField.MapFieldType.SET;
                mapField.name = new RiakString("set_1");
                mapEntry = new MapEntry();
                mapEntry.field = mapField;
                mapEntry.set_value.Add(RiakString.ToBytes("value_1"));
                mapEntry.set_value.Add(RiakString.ToBytes("value_2"));
                mapEntries.Add(mapEntry);

                mapField = new MapField();
                mapField.type = MapField.MapFieldType.REGISTER;
                mapField.name = new RiakString("register_1");
                mapEntry = new MapEntry();
                mapEntry.field = mapField;
                mapEntry.register_value = RiakString.ToBytes("1234");
                mapEntries.Add(mapEntry);

                mapField = new MapField();
                mapField.type = MapField.MapFieldType.FLAG;
                mapField.name = new RiakString("flag_1");
                mapEntry = new MapEntry();
                mapEntry.field = mapField;
                mapEntry.flag_value = true;
                mapEntries.Add(mapEntry);

                return mapEntries;
            };

            updateResp.map_value.AddRange(createMapEntries());

            var map_1_field = new MapField();
            map_1_field.type = MapField.MapFieldType.MAP;
            map_1_field.name = new RiakString("map_1");
            var map_1_entry = new MapEntry();
            map_1_entry.field = map_1_field;
            map_1_entry.map_value.AddRange(createMapEntries());

            updateResp.map_value.Add(map_1_entry);

            Action<Map> verifyMap = (map) =>
            {
                Assert.AreEqual(50, map.Counters["counter_1"]);
                Assert.AreEqual(RiakString.ToBytes("value_1"), map.Sets["set_1"][0]);
                Assert.AreEqual(RiakString.ToBytes("value_2"), map.Sets["set_1"][1]);
                Assert.AreEqual(RiakString.ToBytes("1234"), map.Registers["register_1"]);
                Assert.IsTrue(map.Flags["flag_1"]);
            };

            var mapOp = new UpdateMap.MapOperation();

            var update = new UpdateMap.Builder(mapOp)
                .WithBucketType("maps")
                .WithBucket("myBucket")
                .WithKey("map_1")
                .Build();

            update.OnSuccess(updateResp);

            MapResponse response = update.Response;

            Assert.NotNull(response);
            Assert.AreEqual(key, response.Key);
            Assert.AreEqual(RiakString.ToBytes(context), response.Context);

            verifyMap(response.Value);
            verifyMap(response.Value.Maps["map_1"]);
        }
Exemplo n.º 17
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);
        }
        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;
        }
        public void Maps()
        {
            var builder = new UpdateMap.Builder()
                .WithBucketType("maps")
                .WithBucket("customers")
                .WithKey("ahmed_info");

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Initial import of Ahmed's data and contact");

            var mapOperation = new UpdateMap.MapOperation();

            // Ahmed's first name
            mapOperation.SetRegister("first_name", "Ahmed");

            // Ahmed's phone number
            mapOperation.SetRegister("phone_number", "5551234567");

            builder.WithMapOperation(mapOperation);
            MapResponse response = SaveMap(builder);

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Set Ahmed to NOT be an enterprise customer right now");

            mapOperation = new UpdateMap.MapOperation();
            mapOperation.SetFlag("enterprise_customer", false);

            builder.WithMapOperation(mapOperation);
            response = SaveMap(builder);

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("enterprise_customer flag value");

            Map ahmedMap = response.Value;
            Console.WriteLine("Ahmed enterprise_customer: {0}", ahmedMap.Flags["enterprise_customer"]);

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Add page visits counter for Ahmed");

            mapOperation = new UpdateMap.MapOperation();
            mapOperation.IncrementCounter("page_visits", 1);

            builder.WithMapOperation(mapOperation);
            response = SaveMap(builder);

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Add Ahmed's interests set");

            var interestsAdds = new[] { "robots", "opera", "motorcycles" };

            mapOperation = new UpdateMap.MapOperation();
            mapOperation.AddToSet("interests", interestsAdds);

            builder.WithMapOperation(mapOperation);
            response = SaveMap(builder);

            ahmedMap = response.Value;

            Assert.True(ahmedMap.Sets.GetValue("interests").Contains("robots"));
            Assert.True(ahmedMap.Sets.GetValue("interests").Contains("opera"));
            Assert.True(ahmedMap.Sets.GetValue("interests").Contains("motorcycles"));

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Updating Ahmed's interests");

            mapOperation = new UpdateMap.MapOperation();
            mapOperation.AddToSet("interests", "indie pop");
            mapOperation.RemoveFromSet("interests", "opera");

            builder
                .WithMapOperation(mapOperation)
                .WithContext(response.Context);
            response = SaveMap(builder);

            ahmedMap = response.Value;

            Assert.False(ahmedMap.Sets.GetValue("interests").Contains("opera"));
            Assert.True(ahmedMap.Sets.GetValue("interests").Contains("indie pop"));

            Assert.True(ahmedMap.Sets.GetValue("interests").Contains("robots"));
            Assert.True(ahmedMap.Sets.GetValue("interests").Contains("motorcycles"));

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Adding Annika map");

            mapOperation = new UpdateMap.MapOperation();

            UpdateMap.MapOperation annikaInfoOperation = mapOperation.Map("annika_info");
            annikaInfoOperation.SetRegister("first_name", "Annika");
            annikaInfoOperation.SetRegister("last_name", "Weiss");
            annikaInfoOperation.SetRegister("phone_number", "5559876543");

            builder.WithMapOperation(mapOperation);
            response = SaveMap(builder);

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Annika's first name");

            ahmedMap = response.Value;
            Console.WriteLine(ahmedMap.Maps["annika_info"].Registers.GetValue("first_name"));

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Removing Annika's first name");

            mapOperation = new UpdateMap.MapOperation();
            mapOperation.Map("annika_info").RemoveRegister("first_name");

            builder
                .WithMapOperation(mapOperation)
                .WithContext(response.Context);
            response = SaveMap(builder);

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Storing Annika's plan flags");

            mapOperation = new UpdateMap.MapOperation();
            mapOperation.Map("annika_info")
                .SetFlag("enterprise_plan", false)
                .SetFlag("family_plan", false)
                .SetFlag("free_plan", true);

            builder.WithMapOperation(mapOperation);
            response = SaveMap(builder);

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Is Annika on enterprise plan?");

            ahmedMap = response.Value;
            Console.WriteLine(ahmedMap.Maps["annika_info"].Flags["enterprise_plan"]);

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Adding Annika's widget_purchases counter");

            mapOperation = new UpdateMap.MapOperation();
            mapOperation.Map("annika_info").IncrementCounter("widget_purchases", 1);

            builder.WithMapOperation(mapOperation);
            response = SaveMap(builder);

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Adding Annika's interests in a set");

            mapOperation = new UpdateMap.MapOperation();
            mapOperation.Map("annika_info").AddToSet("interests", "tango dancing");

            builder.WithMapOperation(mapOperation);
            response = SaveMap(builder);

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Remove \"tango dancing\" from Annika's interests");

            mapOperation = new UpdateMap.MapOperation();
            mapOperation.Map("annika_info").RemoveFromSet("interests", "tango dancing");

            builder
                .WithMapOperation(mapOperation)
                .WithContext(response.Context);
            response = SaveMap(builder);

            Console.WriteLine("------------------------------------------------------------------------\n");
            Console.WriteLine("Add specific purchase info to Annika's data");

            mapOperation = new UpdateMap.MapOperation();
            mapOperation.Map("annika_info").Map("purchase")
                .SetFlag("first_purchase", true)
                .SetRegister("amount", "1271")
                .AddToSet("items", "large widget");

            builder.WithMapOperation(mapOperation);
            response = SaveMap(builder);

            Console.WriteLine("Context: {0}", Convert.ToBase64String(response.Context));
        }