gistfile1.txt

### configure ###

app.redis = redis.createClient()

#!!!JUST ADDED THE ERROR HANDLER. I SUSPECT IT COULD BE THE ISSUE. 
redis.debug_mode = true
app.redis.on("error", (err) =>
  console.log("Caught redis client error")
  console.log(err.stack)
  app.redis = redis.createClient()
)

app.subserver = new SubServerClient()

app.mysql = mysql.createConnection MYSQL_CONFIG

handleMySQLDisconnect = (connection) ->
  connection.on 'error', (err) ->
    return unless err.fatal
    throw err if err.code isnt 'PROTOCOL_CONNECTION_LOST'
    console.log "Reconnecting to MYSQL: ", err.stack
    connection = mysql.createConnection connection.config
    handleMySQLDisconnect connection
    connection.connect()
    app.mysql = connection

handleMySQLDisconnect app.mysql

app.cookieParser = express.cookieParser()
app.use app.cookieParser

app.sessionStore = new RedisStore
  client: app.redis
  prefix: "session:"

app.session = express.session
  store: app.sessionStore
  secret: "Nah Nah Nah Nah Nah"
  key: "session"

app.use app.session

============================================================================================================================
### the websocket server ###

socketdomain = require("domain").create()
socketdomain.run( =>
  app.servers.io = socketio.listen 443
  app.servers.io.set "flash policy port", 10843
  app.servers.io.set "log level", 1
  app.servers.io.set "close timeout", 120
  app.servers.io.set "transports", ["websocket", "flashsocket", "xhr-polling", "jsonp-polling"]
  app.servers.io.set "store", new RedisStore(
    redisPub: redisPub
    redisSub: redisSub
    redisClient: redisClient
  )

  app.servers.io.of("/realtime").authorization((handshakeData, callback) ->
    sessionID = handshakeData.query.s
    app.sessionStore.load sessionID, (storeErr, session) =>
      if (storeErr)
        callback(storeErr)
      else
        handshakeData.sessionID = sessionID
        handshakeData.session = session
        callback(null, true)
  ).on "connection", (socket) ->
    if (!socket.handshake.session)
      app.realtime.connect(err, socket, null)
    else
      app.realtime.connect(null, socket, socket.handshake.session)

  # convenience
  app.io = app.servers.io
)

socketdomain.on("error", (err) =>
  console.log ("Caught socket domain error")
  console.log(err.stack)
)

============================================================================================================================

### The websocket connection handler: 

 connect: (err, socket, session) =>
    deferred = Q.defer()
    if err 
      app.log.error "Realtime Error",  err
      return false
    socket.on "error", (socketErr) ->  
      console.log("Caught socket error!")
      console.log(socketErr)
    sessionID = socket.handshake?.sessionID
    if !sessionID
      app.log "Client connected but cannot read session"
      deferred.resolve {}
    else if @clients[sessionID]?
      client = @clients[sessionID]
      client.session = session
      if client.user? and not client.session.__id?
        app.log "Client logged out", sessionID, client.user.get('name')
        for socket in client.sockets
          socket.emit "offline"
        client.emit "offline"
        delete client.user
      else
        app.log "Client socket connected", sessionID
      client.addSocket socket
      deferred.resolve client
    else
      app.log "Client connected", sessionID
      @loadUser(@addClient sessionID, session).then (client) ->
        client.addSocket socket
        client.emit "online"
        deferred.resolve client
    deferred.promise

===============================================================================================================================

### A component that does http requests to another server ###


class SubServerClient extends Emitter
  defaults: ->
    baseUrl: #############################
    websiteId: #
    accessToken: #

  getBalance: (userId) =>

    options =
      url: "#{@baseUrl}/credit/#{userId}"
      headers: @getHeaders()
      json: true
    Q.ninvoke(httpRequest, "get", options).then ([req, response]) ->

      response.body?.balance

  sendCredits: (quantity, fromUserId, toUserId, reference) =>
    options =
      url: "#{@baseUrl}/credit/#{fromUserId}/send"
      headers: @getHeaders()
      form:
        recipientId: toUserId
        quantity: quantity.toFixed 2
        reference: reference
      json: true
    Q.ninvoke(httpRequest, "post", options).then ([req, response]) ->
      success = not response.errors?
      console.log response if not success
      [success, response.body?.balance]