RR

Author: user

Diff for: lua/pusher.lua

@@ -133,7 +133,7 @@ while true do
 				wb:send_close()
 			else
 				-- normal traffic on the channel; copy to websocket
-				local ok, err = wb:send_text(cjson.encode({src=chan, msg=msg}))
+				local ok, err = wb:send_text(msg)
 				if not ok then
 					STATE:die("Couldn't write: " .. err)
 				end

Diff for: nginx.conf

@@ -63,8 +63,8 @@ http {
 			alias static/$1$2;
 		}
 
-		location = /___WS {
-			# Websockets come in here; may have arg: channel name
+		location = /__W__ {
+			# Websockets come in here
             access_by_lua_file 'lua/before.lua';
             content_by_lua_file 'lua/pusher.lua';
 		}

Diff for: python/cfcapp.py

@@ -1,6 +1,6 @@
 #
 import time
-from flask import Flask, json
+from flask import Flask, json, request
 from flask.app import setupmethod
 from threading import Thread
 
@@ -10,24 +10,35 @@ def start(self):
 		super(DaemonThread, self).start()
 
 class WSConnection(object):
-	def __init__(self, app, fid, wsid):
+	def __init__(self, app, wsid, fid):
 		self.app = app
 		self.fid = fid
 		self.wsid = wsid
 
 	def __repr__(self):
 		return '<WSConnection %s fid=..%s>' % (self.wsid, self.fid[-4:])
 
-	def open(self):
+	def created(self):
 		# do something when first connected
+		print "%r: created" % self
 		pass
 
 	def closed(self):
-		# do something after closed; cannot send messages at this point
+		# do something after being closed, but cannot send messages at this point
+		print "%r: closed" % self
 		pass
 
 	def tx(self, msg):
-		self.app.tx(msg, wsid=self.wsid)
+		self.app.tx(msg, conn=self)
+
+class CFCContextVars(object):
+	# This class is put into the context of all templates as "CFC"
+	# 
+	@property
+	def WEBSOCKET_URL(self):
+		" Provide a URL for the websocket to be used "
+		scheme = request.environ['wsgi.url_scheme']
+		return '%s://%s/__W__' % ('ws' if scheme == 'http' else 'wss', request.host)
 
 class CFCFlask(Flask):
 	''' Extensions to Flask() object to support app needs for CFC frontend '''
@@ -45,20 +56,33 @@ class CFCFlask(Flask):
 	ping_rate = 15		# seconds
 
 	def __init__(self, *a, **kws):
-		# list of functions that want to receive data from websocket clients
+
+		# List of functions that want to receive data from websocket clients
+		# Extend this using the decorator app.ws_rx_handler
 		self.ws_rx_handlers = []
 
 		# map of all current connections
 		self.ws_connections = {}
 
+		# Domains we are implementing today; lowercase, canonical names only.
+		# you can still redirect www. variations and such, but don't include them
+		# in this list.
 		self.my_vhosts = kws.pop('vhosts', ['lh', 'none'])
+
+		# We need some threads. You can add yours too, by decorating with
+		# app.background_task
+		self.ws_background_tasks = [ self.pinger, self.rxer ]
 
 		super(CFCFlask, self).__init__(*a, **kws)
 
+		@self.context_processor
+		def extra_ctx():
+			return dict(CFC = CFCContextVars())
+
 	def pinger(self):
 		# Keep all connections alive with some minimal traffic
 		RDB = self.redis
-		RDB.publish('bcast', 'server restart')
+		#RDB.publish('bcast', 'RESTART')
 
 		while 1:
 			RDB.publish('bcast', 'PING')
@@ -79,8 +103,7 @@ def rxer(self):
 			vhost = vhost[3:]
 			assert vhost in self.my_vhosts, "Unexpended hostname: %s" % vhost
 
-			# Data from WS is wrapped in some json by LUA code. Trustable.
-			self.logger.debug('before = %r' % here)
+			# This data from WS is already wrapped as JSON by LUA code. Trustable.
 			try:
 				here = json.loads(here)
 			except:
@@ -109,24 +132,32 @@ def rxer(self):
 			conn = self.ws_connections.get(wsid, None)
 			if not conn:
 				# this will happen if you restart python while the nginx/lua stays up
-				self.logger.warn('New WSID')
+				self.logger.warn('Existing/unexpected WSID')
 				conn = self.ws_new_connection(wsid, fid)
 
 			# Important: do not trust "msg" here as it comes
 			# unverified from browser-side code. Could be nasty junk.
-			self.logger.debug('here = %r' % here)
 			msg = here.get('msg', None)
 
+			if msg[0] == '{' and msg[-1] == '}':
+				# looks like json
+				try:
+					msg = json.loads(msg)
+				except:
+					self.logger.debug('RX[%s] got bad JSON: %r' % (vhost, msg))
+					
+
 			for handler in self.ws_rx_handlers:
 				handler(vhost, conn, msg)
 
-			self.logger.debug('RX[%s] %r' % (vhost, msg))
+			if not self.ws_rx_handlers:
+				self.logger.debug('RX[%s] %r' % (vhost, msg))
 
 	def ws_new_connection(self, wsid, fid):
 		''' New WS connection, track it.
 		'''
 		self.ws_connections[wsid] = rv = WSConnection(self, wsid, fid)
-		rv.open()
+		rv.created()
 		return rv
 
 	def tx(self, msg, conn = None, fid=None, wsid=None, bcast=False):
@@ -146,27 +177,40 @@ def tx(self, msg, conn = None, fid=None, wsid=None, bcast=False):
 		elif bcast:
 			chan = 'bcast'
 
+		if not isinstance(msg, basestring):
+			# convert into json, if not already
+			msg = json.dumps(msg)
+
 		self.redis.publish(chan, msg)
 
-	def ws_close(self, wsid):
+	def ws_close(self, wsid_or_conn):
 		'''
 			Close a specific web socket from server side; perhaps because it mis-behaved.
 
 			LUA code detects this message and kills it's connection.
 		'''
-		self.tx('CLOSE', wsid=wsid)
+		self.tx('CLOSE', wsid=getattr(wsid_or_conn, 'wsid', wsid_or_conn))
 
 	@setupmethod
 	def ws_rx_handler(self, f):
-		"""Registers a function to be called when traffic is received via web sockets
+		"""
+			Registers a function to be called when traffic is received via web sockets
 
 		"""
 		self.ws_rx_handlers.append(f)
 		return f
+
+	@setupmethod
+	def background_task(self, f):
+		"""
+			Registers a function to be run as a background thread
+		"""
+		self.ws_background_tasks.append(f)
+		return f
 
 
 	def start_bg_tasks(self):
 		''' start long-lived background threads '''
-		DaemonThread(name="pinger", target=self.pinger, args=[]).start()
-		DaemonThread(name="rxer", target=self.rxer, args=[]).start()
+		for fn in self.ws_background_tasks:
+			DaemonThread(name=fn.__name__, target=fn, args=[]).start()
 

Diff for: python/example_app.py

@@ -1,15 +1,42 @@
+import time
 from flask import request, Response, render_template, json
 from cfcapp import CFCFlask
 
 app = CFCFlask(__name__)
 
 @app.ws_rx_handler
 def rx_data(vhost, conn, msg):
-	say = json.loads(msg)['say']
-	m = json.dumps({'from': conn.fid[-8:].upper(),
-					'content': say})
+	say = msg['say']
+
+	m = {'from': conn.fid[-8:].upper(), 'content': say}
 	app.tx(m, bcast=True)
 
+class Robot(object):
+	def __init__(self):
+		self.heard = set()
+
+		@app.background_task
+		def robot1():
+			while 1:
+				say = "I'm a robot and the time is %s" % time.strftime('%T')
+				m = {'from': 'Robot1', 'content': say}
+				app.tx(m, bcast=True)
+				time.sleep(15)
+
+		@app.ws_rx_handler
+		def rx_data(vhost, conn, msg):
+			said = msg['say']
+			if 'robot' in said: return
+
+			user = conn.fid[-8:].upper()
+			if user not in self.heard:
+				m = {'from': 'Robot1', 'content': "Hello %s" % user}
+				app.tx(m, bcast=True)
+				self.heard.add(user)
+
+Robot()
+	
+
 @app.route('/')
 def ws_test():
 	return render_template("chat.html", vhost=request.host)

Diff for: python/fserver.py

@@ -60,7 +60,7 @@ def start_server(ip, port, debug, redis_url):
 
 
 	if debug:
-		app.run(host="0.0.0.0", port=port)
+		app.run(host="0.0.0.0", port=port, debug=True)
 	else:
 		print "Running as FastCGI at %s:%d" % (ip, port)
 		MyWSGIServer(app, bindAddress=(ip, port), multiplexed=True, umask=0).run()

Diff for: python/templates/chat.html

@@ -1,17 +1,88 @@
 <!DOCTYPE html>
-<meta charset="utf-8" />
-<title>CFC Chat Demo</title>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>Bootstrap 101 Template</title>
 
-<h2>CFC Chat Demo</h2>
+    <!-- Bootstrap -->
+	<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.2/css/bootstrap.min.css">
+	<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.2/css/bootstrap-theme.min.css">
 
-<button onclick="doSend('Hello!')">Say: Hello</button>
-<button onclick="doSend('Bye.')">Say: Bye</button>
-<button onclick="doSend('Testing 1, 2, 3...')">Say: Testing</button>
+    <!-- HTML5 shim and Respond.js for IE8 support of HTML5 elements and media queries -->
+    <!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
+    <!--[if lt IE 9]>
+      <script src="https://oss.maxcdn.com/html5shiv/3.7.2/html5shiv.min.js"></script>
+      <script src="https://oss.maxcdn.com/respond/1.4.2/respond.min.js"></script>
+    <![endif]-->
+
+<style>
+body {
+  padding-top: 50px;
+}
+.demo-template {
+  padding: 40px 15px;
+}
+
+#output {
+	max-height: 320px;
+	overflow-y: scroll;
+}
+
+#output pre {
+	padding: 4px;
+	margin: 0;
+}
+</style>
+
+
+
+  </head>
+  <body>
+    <nav class="navbar navbar-inverse navbar-fixed-top">
+      <div class="container">
+        <div class="navbar-header">
+          <a class="navbar-brand" href="#">CFC Demo</a>
+        </div>
+      </div>
+    </nav>
+
+    <div class="container">
+	  <div class="row">
+		<div class="col-md-7">
+			<h3>About</h3>
+			<p>
+				This is just a very simple demo of websocket-based chat. 
+				Much more is possible, including dynamic page content loading or
+				calling JS methods from the server side. The ultimate would be 
+				to load only a single HTML page, and then tell the browser to
+				fetch other resources only as needed.
+			</p>
+		</div>
+		<div class="col-md-5">
+		  <div class="demo-template">
+			<h3>Chat Box</h3>
+
+			<button class="btn btn-default" onclick="doSend('Hello!')">Say: Hello</button>
+			<button class="btn btn-default" onclick="doSend('Bye.')">Say: Bye</button>
+			<button class="btn btn-default" onclick="doSend('Testing 1, 2, 3...')">Say: Testing</button>
+
+			<hr>
+			<div id="output"></div>
+		  </div>
+		</div>
+	</div>
+
+    <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.2/jquery.min.js"></script>
+	<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.2/js/bootstrap.min.js"></script>
+
+	<script language="javascript" type="text/javascript">
+		{% include "websocket.js" with context %}
+	</script>
+
+  </body>
+</html>
 
-<hr>
-<div id="output"></div>
 
 
-<script language="javascript" type="text/javascript">
-	{% include "websocket.js" with context %}
-</script>

Diff for: python/templates/websocket.js

@@ -1,4 +1,4 @@
-var wsUri = "ws://{{request.host}}/___WS";
+var wsUri = "{{CFC.WEBSOCKET_URL}}";
 
 var output;
 function init() {
@@ -22,31 +22,28 @@ function onClose(evt) {
 
 function onMessage(evt) {
 
-	var frame = JSON.parse(evt.data);
-	console.log("rx=", frame);
+	var msg = JSON.parse(evt.data);
+	console.log("msg=", msg);
 
-	if(!frame.msg) return;
-
-	var app = JSON.parse(frame.msg);
-	console.log("app=", app);
-
-	if(app) {
-		writeToScreen('<span style="color: blue;">' + app.from + ':</span> ' + app.content);
+	if(msg.from) {
+		writeToScreen('<span style="color: blue;">' + msg.from + ':</span> ' + msg.content);
 	}
 }
 function onError(evt) {
 	writeToScreen('<span style="color: red;">ERROR:</span> ' + evt.data);
 }
 function doSend(message) {
 	message = JSON.stringify({'say': message});
-	//writeToScreen("TX: " + message);
 	websocket.send(message);
 }
 function writeToScreen(message) {
 	var pre = document.createElement("pre");
 	pre.style.wordWrap = "break-word";
 	pre.innerHTML = message;
 	output.appendChild(pre);
+
+	$(output).scrollTop($(output)[0].scrollHeight);
+
 }
 
 window.addEventListener("load", init, false);