r = RedisCall.new

prefix = r.key('foo')

# set the 'foo.bar.qux' to 'content' with 1 day expiration
r.setex prefix+:bar+'qux', 1.day, 'content'
r.setex prefix/:bar/'qux', 1.day, 'content'

# get 'foo.bar.qux'
r.get prefix/:bar/'qux'

class MyStorage < RedisCall
  def store key_name, value
    multi do
      del key(:prefix)/key_name/:some_state
      set key(:prefix)/key_name, value
    end
  end
end

queue = RedisQueue::Base.new('foo')
queue.push(hello: 'darling')

queue.name
queue.length
queue.backup_length

queue.pop_all
queue.backup_elements
queue.backed_up_pop_all

subqueue = RedisQueue::Base.new(queue.name/:subqueue)

class Handler
  def start
    @queue = RedisQueue::Base.new 'queue_name', connect: true
    @queue.restore_backup

    @handler = Thread.networkety do
      loop do
        @queue.backed_up_blocking_pop do |message|
          puts message.inspect
        end
      end
    end
  end

  def join
    @handler.log_join "Handler thread joined"
  end

  def stop
    @queue.disconnect @handler
  end
end

class MyQueue < RedisQueue::Base
  def encode element
    super(element.as_json(:except => [:serialized]))
  end

  def decode raw
    MyElement.new(super(raw))
  end
end

RedisQueue::Base.new('queue_name').config[:attr]
# => 'value'

class QueueListController
  # Queue names currently are not checked for funny characters by library,
  # so a potential of Redis command injection exists.
  def filtered_id
    params[:id].tr('^A-Za-z0-9.', '')
  end

  def index
    @queues = RedisQueue::Base.all
  end

  def destroy
    @queue = RedisQueue::Base.find filtered_id
    @queue.destroy
  end
end

class MessagesController
  def queue
    @queue ||= RedisQueue::Base.new('input')
  end

  def output_queue
    @output_queue ||= RedisQueue::Base.new('output')
  end

  def raw_message
    params[:message][:serialized]
  end

  def index
    @messages = queue.elements
    @messages = queue.backup_elements

    @messages = queue.pop_all
    @messages = queue.backed_up_pop_all
  end

  def update
    queue.insist do # Retry on optimistic lock fail
      queue.watch_backup # Optimistic locking

      if queue.raw_backup_elements.include? raw_message
        @message = queue.decode raw_message

        if @message.valid?

          queue.multi do
            queue.remove_raw_backup_element raw_message
            output_queue.push "some message"
          end

          respond_to do |format|
            format.html { render :nothing => true, status: :created }
          end
        else
          respond_to do |format|
            format.html { render partial: 'form', :locals => {message: @message}, status: :unprocessable_entity }
          end
        end
      else
        respond_to do |format|
          format.html { render text: "The message you are trying to update is gone", status: :gone }
        end
      end
    end
  end

  def destroy
    queue.remove_raw_element raw_message
  end
end

before_fork do |server, worker|
  RedisCall.new.disconnect
end

after_fork do |server, worker|
  RedisCall.new.connect
end