Does SETNX work properly in REDIS cluster? or it is meant to be work only in single instance REDIS?
Is there a official documentation regarding this? Official doc does say that it is discouraged to use for locking in favor of distributed locking.
SETNX is fully supported by any Redis topology, including stand-alone and cluster. The official docs says the suggested locking pattern mentioned there is discouraged, not the command itself:
[...] The following pattern is discouraged in favor of the Redlock algorithm which is only a bit more complex to implement, but offers better guarantees and is fault tolerant.
[...]
Related
We are kind of evaluating the cons and pros between Ignite and Redis.
On official documents, it is said Ignite is partially Redis compliant. With that said, some commands / function come with limitations on the documents. Are there other unsupported features / known issues that Ignite-Redis does not clarify on the document?
Thanks in advance.
The commands listed on the docs page should work.
You can also check out known issues that mention Redis.
If you find that something else doesn't work, please report it to user#ignite.apache.org.
We have been using Aeropsike exentsively as key-value store only. However now I couldn't find a way to actually save a lock in Aeropspike like the way we do in Redis.
I guess, I can always save native application lock as blobs, but that means I will be limited to a particular implementation in my application.
Don't believe you can "save" locks in Aerospike. Any form of locking has to be implemented at the Application level and then you have to deal with the locking client abandoning the lock.
I would suggest that you read Martin Kleppmann's Redlock Discussion. It covers the responses people in the distributed systems community had to Antirez's debating the topic, following Kleppmann's earlier article How to do distributed locking.
Building a DLM is not a trivial problem at all, and Redlock fails as one. If you are up for it, you can consider writing such a thing over the linearizable strong consistency mode of Aerospike Enterprise Edition 4.0.
As opposed to Redis and its variants, Aerospike EE 4.0 passes Jepsen.
We're using Redis but considering Infinispan. Redis supports list, hashset, set, and sorted set, and offers native functions to operate over those structures, but does Infinispan support the same?
I know Infinispan will store any Java object, but Redis offers functions that operate on elements without having to explicitly retrieve them. I was wondering if Infinispan supports the same.
Infinispan does not support this out-of-the-box - there is some support for AtomicHashMaps, although I've heard that there may be issues with those.
The main feature you should be looking for is the DeltaAware interface - this allows you to build such collections, sending just the 'operation' that should be executed on the value.
There were some attempts to do so - check out infinispan-contrib (though I don't have any experience with that).
Is there an article or resource on getting started with BookSleeve Redis? Thanks
These are some of the articles/links I read when getting upto speed:
http://marcgravell.blogspot.com/2011/04/async-redis-await-booksleeve.html
http://marcgravell.blogspot.com/2011/07/booksleeve-transactions-hashes-and.html
https://code.google.com/p/booksleeve/
http://redis.io/
besides that, search stackoverflow for related questions:
https://stackoverflow.com/questions/tagged/booksleeve
There is not a ton out there, you need to roll up your sleeves and dig in.
Book sleeve is just a wrapper around redis, so any data decisions really relate equally to any redis guide. http://redis.io would be a starting place. In terms of the API, the only things that should need highlighting are:
most operations are async and are exposed via the Task api; this allows a range of usage patterns including (but not limited to) the new "async"/"await" keywords
the operations are split by data type, so .Strings, .Hashes, etc
a connection is a thread-safe multiplexer and is designed to be used by multiple callers concurrently - you do not (and should not) need to use a connection scoped per caller
I am interested in what things you would want me to include in more detailed documentation. What would be useful? What is unclear? What do you need?
If you can describe what you need, I can write it :p
I'm looking for articles and references that give an overview of 'queueing' (I'm probably not even using the right term here). I'm hoping for an introductory styled guide through a world of Redis, RabbitMQ, Celery, Kombu, and whatever other components exist that I haven't read about yet, and how they fit together.
My problem is I need to queue up background tasks for issued by my Django website, and every blog and article I read recommend different solutions.
Lots of options available to you, and your choice will likely come down to personal preference and what dependencies you feel comfortable installing.
I'll give a vote for Redis. I evaluated RabbitMQ, ActiveMQ, HornetQ, and Redis and found Redis to offer the best mix of ease of installation, simplicity, and performance.
It's technically not a message queue, but the push/pop primitives for the list types provide atomic queue-like operations, so it can effectively be used as a queue. It has worked well for us.
One python specific project on top of Redis you might look at:
http://richardhenry.github.com/hotqueue/tutorial.html
Very simple. But again, all the other options, like Celery, are viable too.
RabbitMQ has a good introduction here: http://www.rabbitmq.com/getstarted.html There's examples in Python, even.
HornetQ has a very good documentation, and it's simple to install.
You can find the documentation at www.hornetq.org, and you would have several examples available with the distribution.