混合redis actioncontroller :: live-Rails应用

Question

I am using for the first time redis to put chat functionality in my rails app, following this

I have in my javascript`

$(document).ready ->
  source = new EventSource('/messages/events')
  source.addEventListener 'messages.create', (e) ->
    message = $.parseJSON(e.data).message
    console.log(message)
    $(".chat-messages").append "#some code"

and in my message controller

def create
    response.headers["Content-Type"] = "text/javascript"
    attributes = params.require(:message).permit(:content, :sender_id, :sendee_id)
    @message = Message.create(attributes)
    respond_to do |format|
      format.js { render 'messages/create.js.erb' }
    end
    $redis.publish('messages.create', @message.to_json)
  end

  def events
    response.headers["Content-Type"] = "text/event-stream"
    redis = Redis.new
    redis.subscribe('messages.*') do |on|
      on.message do |pattern, event, data|
        response.stream.write("event: #{event}\n")
        response.stream.write("data: #{data}\n\n")
      end
    end
  rescue IOError
    logger.info "Stream closed"
  ensure
    redis.quit
    response.stream.close
  end

The problem is that first, nothing is logged in my console, and second I get numbers of random ConnectionTimeoutError errors. Some one hava an idea what's going on

Answer 1

Pre-Reqs:

• Ruby 2.0.0+
• Rails 4.0.0+
• Redis
• Puma

---

Initializer:

Create a redis.rb initializer file in the config/initializers directory, globalizing an instance of redis . It's also a good idea to set up a heartbeat thread (Anything from 5 seconds to 5 minutes is okay, depending on your requirements):

$redis = Redis.new

heartbeat_thread = Thread.new do
  while true
    $redis.publish("heartbeat","thump")
    sleep 15.seconds
  end
end

at_exit do
  # not sure this is needed, but just in case
  heartbeat_thread.kill
  $redis.quit
end

---

Controller:

You need to add two methods to your ChatController , pub and sub . The role of pub is to publish chat events and messages to redis , and sub to subscribe to these events. It should look something like this:

class ChatController < ApplicationController
    include ActionController::Live

    skip_before_filter  :verify_authenticity_token

    def index
    end

    def pub
        $redis.publish 'chat_event', params[:chat_data].to_json
        render json: {}, status: 200
    end

    def sub
        response.headers["Content-Type"] = "text/event-stream"

        redis = Redis.new
        redis.subscribe(['chat_event']) do |on|
            on.message do |event, data|
                response.stream.write "event: #{event}\ndata: #{data}\n\n"
            end
        end
    rescue IOError
        logger.info "Stream Closed"
    ensure
        redis.quit
        response.stream.close
    end
end

In your routes , make pub a POST and sub a GET , and match the path to something like /chat/publish and /chat/subscribe .

---

Coffeescript / Javascript:

Assuming your actual webpage for the chat app is at /chat , you need to write some Javascript to actually send and receive chat messages.

For ease of understanding, let's suppose your webpage only has a textbox and a button. Hitting the button should publish the content of the textbox to the chat stream, we can do that using AJAX:

$('button#send').click (e) ->
    e.preventDefault()
    $.ajax '/chat/publish',
        type: 'POST'
        data: {
            chat_data: {
                message: $("input#message").val(),
                timestamp: $.now()
            }
        }
        error: (jqXHR, textStatus, errorThrown) ->
            console.log "Failed: " + textStatus 
        success: (data, textStatus, jqXHR) ->
            console.log "Success: " + textStatus

Now, you need to be able to subscribe and receive the chat messages as well. You need to use EventSource for this. Using EventSource , open a channel for SSE so that you can receive events, and use that data to update the view. In this example, we will only log them to the javascript console.

The code should look something like this:

$(document).ready ->
    source = new EventSource('/chat/subscribe')
    source.addEventListener 'chat_event', (e) ->
        console.log(e.data)

---

Enable Parallel Requests:

In your development environment, you'll have to enable parallel requests by adding these two lines to your config/environments/development.rb :

config.preload_frameworks = true
config.allow_concurrency = true

Now fire up your browser, browse to /chat and see the magic. When you type a message and click the button, the message will be received by all instances of that webpage.

---

Well this is how you make a basic chat application in rails using ActionController::Live and Redis . The final code would obviously be very different depending on your requirements but this should get you started.

Some more resources you should check out:

• Tender Love Making - Is it Live?
• Railscasts - #401 - ActionController::Live
• SitePoint - Mini Chat with Rails and SSEs
• Github - mohanraj-ramanujam / live-stream
• Thoughtbot - Chat Example using SSEs

Answer 2

Although I've not used redis in this capacity (a mediator for "live" data), I managed to get this functionality working with Pusher

---

Redis

I don't understand how you're keeping the connection open between your app & Redis. You'll need some sort of web socket or concurrent-connection tech in place to handle the updates -- and to my knowledge, Redis does not handle this directly

If you look at this example , it uses a server called Goliath to handle the asynchronous connectivity:

When tiny-chat connects to the server it sends a GET request to /subscribe/everyone where everyone is the name of the channel and with the “Accept” header set to text/event-stream. The streaming middleware (above) receives this request and subscribes to a redis Pub/Sub channel. Since Goliath is non-blocking multiple clients can be listening for events without tying up a Heroku dyno. The payload of a server sent event looks like this:

That basically uses Middleware to connect you to the redis server -- allowing you to receive updates as required

---

Code

Although I can't pinpoint any errors specifically, I can give you some code we're using (using Pusher ):

    #config/initializers/pusher.rb
    Pusher.url = ENV["PUSHER_URL"]

    Pusher.app_id = ENV["PUSHER_APP_ID"]
    Pusher.key = ENV["PUSHER_KEY"]
    Pusher.secret = ENV["PUSHER_SECRET"]

    #app/controllers/messages_controller.rb
    def send_message
        id = params[:id]
        message = Message.find(id).broadcast!
        public_key = self.user.public_key
        Pusher['private-user-' + public_key].trigger('message_sent', {
            message: "Message Sent"
        })
    end

    #app/views/layouts/application.html.erb
    <%= javascript_include_tag "http://js.pusher.com/2.1/pusher.min.js" %>

    #app/assets/javascripts/application.js
    $(document).ready(function(){
    #Pusher
    pusher = new Pusher("************",
        cluster: 'eu'
    )

    channel = pusher.subscribe("private-user-#{gon.user}")
    channel.bind "multi_destroy", (data) ->
        alert data.message

    channel.bind "message_sent", (data) ->
        alert data.message
    });