def create_new_thread_with_topic(title, session_id, course_id, topic, is_instructor): newThread = Thread(title=escape(title), original_poster=session_id, course_id=course_id, topic=topic, pinned=is_instructor) newThread.save() unique_key = 'threads' + course_id + topic redis_publisher = RedisPublisher(facility=unique_key, broadcast=True) message = RedisMessage( json.dumps({ 'type': 'thread_created', 'thread_id': newThread.pk, 'thread_title': newThread.title, 'replyNum': newThread.getNumberOfReplies(), 'pinned': newThread.pinned, })) redis_publisher.publish_message(message) redis_publisher = RedisPublisher(facility=session_id, broadcast=True) message = RedisMessage( json.dumps({ 'type': 'created-thread', 'thread_id': newThread.pk })) redis_publisher.publish_message(message) return newThread
def process_workbook(self, filepaths): redis_publisher = RedisPublisher(facility='processing', **{'broadcast': True}) counter = 1 redis_data = { "total_rows": 0, "rows_processed": 0, "rows_ignored": 0, "jd_created": 0, "error": False, "error_message": "" } for filepath in filepaths: try: data = self.readxlsx(filepath) redis_data["total_rows"] += len(data) message = RedisMessage(json.dumps(redis_data)) redis_publisher.publish_message(message) from core.models import WorkBook for row in data: redis_data["rows_processed"] += 1 workbook, created = WorkBook.objects.get_or_create( id=row['ID']) if not created: redis_data["rows_ignored"] += 1 else: redis_data['jd_created'] += 1 workbook.role = row['Role'] workbook.level = row['Level'] workbook.primary_skill = row['Primary Skill'] workbook.secondary_skill = row['Secondary Skill'] workbook.description = row['Description'] workbook.save() message = RedisMessage(json.dumps(redis_data)) redis_publisher.publish_message(message) counter += 1 except KeyError: redis_data['error'] = True redis_data[ 'error_message'] = "Some fields are missing in file %s<br>" % filepath.replace( 'media/', '') # noqa message = RedisMessage(json.dumps(redis_data)) redis_publisher.publish_message(message) continue except xlrd.XLRDError: redis_data['error'] = True redis_data[ 'error_message'] += "Invalid File Provided %s<br>" % filepath.replace( 'media/', '') # noqa message = RedisMessage(json.dumps(redis_data)) redis_publisher.publish_message(message) continue
def setUp(self): self.facility = u'unittest' self.prefix = getattr(settings, 'WS4REDIS_PREFIX', 'ws4redis') self.websocket_base_url = self.live_server_url.replace('http:', 'ws:', 1) + u'/ws/' + self.facility self.message = RedisMessage(''.join(unichr(c) for c in range(33, 128))) self.factory = RequestFactory() # SessionStore # as used here: http://stackoverflow.com/a/7722483/1913888 settings.SESSION_ENGINE = 'redis_sessions.session' engine = import_module(settings.SESSION_ENGINE) store = engine.SessionStore() store.save() self.session = store self.client.cookies[settings.SESSION_COOKIE_NAME] = store.session_key
def mpc_idle(self): """Idle until event received from MPD. Note: this is blocking. To break this loop, toggle some switch on MPD. """ self.ensure_connected() res = [''] if self.connected: res = self.client.idle() self.check_party_mode(res) if 'update' in res and 'updating_db' not in self.client.status(): # let ratings scanner do rescan if database updated self.main.rescan_ratings = True # clear yellow LED write_gpio_pipe('1 0') elif 'update' in res: # raise yellow LED write_gpio_pipe('1 1') if 'playlist' in res: # Tell playlist view to update its status. redis_publisher = RedisPublisher(facility='piremote', broadcast=True) redis_publisher.publish_message(RedisMessage('playlist')) if 'player' not in res: return # Publish current player state via websocket via redis broadcast. state = self.client.status() cur = self.client.currentsong() state_data = dict(event=res) msg = json.dumps(state_data) redis_publisher = RedisPublisher(facility='piremote', broadcast=True) redis_publisher.publish_message(RedisMessage(msg)) # Check if playing and file changed --> insert into history if so. if 'state' in state and state['state'] == 'play': file = cur['file'] if file != self.last_file: self.last_file = file if 'artist' in cur and 'title' in cur: title = '%s - %s' % (cur['artist'], cur['title']) elif 'title' in cur: title = cur['title'] else: no_ext = os.path.splitext(file)[0] title = os.path.basename(no_ext).replace('_', ' ') self.insert_into_history(file, title)
def test_publish(request): pref = settings.MY_PREFIX redis_publisher = RedisPublisher(facility=pref, broadcast=True) message = RedisMessage( json.dumps({ 'type': 'test', 'message': 'this is a test message from server to everyone!' })) redis_publisher.publish_message(message) if request.GET.get('facility', None): redis_publisher = RedisPublisher(facility=request.GET['facility'], broadcast=True) redis_publisher.publish_message( RedisMessage('this is a test message from server to group!')) return HttpResponse('OK')
def stk_push(phone_number, price, first_name, last_name, user_name): push_url = 'http://pay.brandfi.co.ke:8301/api/stkpush' push_params = { "clientId": "2", "transactionType": "CustomerPayBillOnline", "phoneNumber": phone_number, "amount": "1", "callbackUrl": "http://pay.brandfi.co.ke/payfi-success", "accountReference": "demo", "transactionDesc": "Test" } headers = {'Content-type': 'application/json'} r = requests.post(push_url, json=push_params, headers=headers) parsed_json = json.loads(r.text) checkoutRequestId = parsed_json['CheckoutRequestID'] mobile_number = phone_number.replace("254", "0") stk_push_query = STKPushQuery( checkoutRequestId, mobile_number, first_name, last_name, user_name) """Example of how to send server generated events to clients.""" while not stk_push_query.is_result: stk_push_query.push_query() redis_publisher = RedisPublisher(facility='foobar', broadcast=True) message = RedisMessage(stk_push_query.result) redis_publisher.publish_message(message) if(stk_push_query.is_result): break
def notify_user(user_names: List[str], content: dict): try: redis_publisher = RedisPublisher(facility=settings.FACILITY_WS4REDIS, broadcast=False, users=user_names) message = RedisMessage(json.dumps(content)) redis_publisher.publish_message(message) except: logging.exception('Error while sending notification to users "%s"', user_names)
def listen_and_replay_to_redis(self): logger = logging.getLogger("django") tid = random.randint(1, 1000) logger.debug(" >> [%s] websocket starting thread" % tid) try: redis_publisher = RedisPublisher(facility='foobar', broadcast=True) while True: data = str(uuid.uuid4()) #self.counter += 1 #data = "%s - %s" % (data, self.counter) redis_publisher.publish_message(RedisMessage(data)) ttw = random.uniform(3, 10) logger.debug(" >> [%s] websocket thread %s: %s waiting %s seconds" % (tid, datetime.now().strftime("%H:%M:%S"), data, ttw)) time.sleep(ttw) except Exception as e: logger.debug(" >> [%s] websocket thread error: %s" % (tid,e)) logger.debug(" >> [%s] websocket thread dying" % tid)
def group_post(request): redis_publisher = RedisPublisher(facility='myg', groups=request.POST.get('group')) msg = request.POST.get('message') message = RedisMessage(request.POST.get('user') + ": " + msg) redis_publisher.publish_message(message) return HttpResponse('OK')
def display(msg, task_id, color=None, stderr=False, screen_only=False, log_only=False, runner=None): # prevent a very rare case of interlaced multiprocess I/O log_flock(runner) while msg.startswith("\n"): msg = msg.replace("\n", "") msg2 = msg + '\n' if color: msg2 = stringc(msg, color) + '\n' logger.debug('TASK_ID: {task_id} | MSG: {message}'.format(task_id=task_id, message=msg2)) # Pusblish the message on websocket redis_publisher = RedisPublisher(facility=task_id, broadcast=True) redis_message = RedisMessage(msg2) redis_publisher.publish_message(message=redis_message) # Store the message into a redis list to let the user get all # history of the logs redis_connection.rpush('tasks:' + task_id, msg2) # reset the expire of the list if settings.WS4REDIS_EXPIRE: if settings.WS4REDIS_EXPIRE > 0: redis_connection.expire('tasks:' + task_id, settings.WS4REDIS_EXPIRE) log_unflock(runner)
def old_listen_and_replay_to_redis(): TCP_IP = '127.0.0.1' TCP_PORT = 5555 BUFFER_SIZE = 1024 redis_publisher = RedisPublisher(facility='foobar', broadcast=True) s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) s.bind((TCP_IP, TCP_PORT)) s.listen(1) while True: conn, addr = s.accept() print 'Connection address:', addr data = conn.recv(BUFFER_SIZE) if not data: continue try: redis_publisher.publish_message(RedisMessage(data)) except Exception as e: print "could not publish in redis because %s" % e conn.send("Thank you for your message. Bye.\n") conn.close()
def get(self, request, *args, **kwargs): welcome = RedisMessage( 'Hello everybody' ) # create a welcome message to be sent to everybody RedisPublisher(facility='foobar', broadcast=True).publish_message(welcome) return super(BroadcastChatView, self).get(request, *args, **kwargs)
def dumpTargetData(self, request, pk=None): connectionCheck() ids = json.loads(request.data['ids']) data = '' count = 1 for pk in ids: try: target = Target.objects.get(pk=pk) target.wasSent() data += str(count) + '\t' + str(target.ptype) + '\t' + str( target.latitude ) + '\t' + str( target.longitude ) + '\t' + target.orientation + '\t' + target.shape + '\t' + target.background_color + '\t' + target.alphanumeric + '\t' + target.alphanumeric_color + '\t' + target.picture.url + '\n' count += 1 except Target.DoesNotExist: continue # websocket response for "sent" redis_publisher = RedisPublisher(facility='viewer', sessions=gcsSessions()) redis_publisher.publish_message( RedisMessage(json.dumps({ 'target': 'sent', 'ids': ids }))) return Response({'data': data})
def lanzafinllamada(request, base, agente): if Agente.objects.filter(anexo=int(agente)).count() > 1: a = simplejson.dumps('Existe muchos agentes agente con el anexo ' + agente) return HttpResponse(a, content_type="application/json") if Agente.objects.filter(anexo=int(agente)).count() == 0: a = simplejson.dumps('No existe el agente con anexo ' + agente) return HttpResponse(a, content_type="application/json") _agente = Agente.objects.get(anexo=int(agente)) _agente.estado_id = 3 _agente.id_estado = 4 _agente.save() redis_publisher = RedisPublisher( facility='foobar', users=[_agente.user.username, 'edeamat', 'scondezo']) message = RedisMessage('llamada-' + str(base)) redis_publisher.publish_message(message) a = simplejson.dumps('Se lanzo FIN llamada al agente con el anexo ' + agente) return HttpResponse(a, content_type="application/json")
def detalle_venta(request, id_produccion): if request.method == 'POST': instance = Produccion() telefono = request.POST['telefono_1'] instance = Produccion.objects.get(id=id_produccion) form = ProduccionForm(request.POST or None, instance=instance) if form.is_valid(): form.save() redis_publisher = RedisPublisher(facility='foobar', users=[request.user.username]) message = RedisMessage('llamada-' + str(telefono)) redis_publisher.publish_message(message) return render(request, 'colasIN/exito.html', {}) if request.method == 'GET': incidencia = Produccion.objects.get(id=id_produccion) incidenciaform = ProduccionForm(instance=incidencia) return render(request, 'colasIN/detalle_venta.html', { 'incidenciaform': incidenciaform, 'incidencia': incidencia })
def gdelete(request): groupname = request.POST.get('name', 0) rd = StrictRedis() pref = settings.MY_PREFIX prefg = pref + ":" + groupname user = str(request.user) print "received request for deleting", groupname, "from", user ismember = rd.sismember(pref + ":groups", groupname) if not ismember: return JsonResponse({ 'done': False, 'reason': 'No such group name' }) # now check whether the requesting user is the one who created the group d = rd.hgetall(prefg + ":hash") if d['owner'] != user: return JsonResponse({ 'done': False, 'reason': 'Only group owner can delete the group' }) rd.srem(pref + ":groups", groupname) rd.delete(prefg + ":hash", pref + ":" + groupname) rd.delete(pref + ":" + groupname) redis_publisher = RedisPublisher(facility=pref, broadcast=True) redis_publisher.publish_message( RedisMessage(json.dumps({ "type": "group_delete", "name": groupname }))) return JsonResponse({'done': True})
def websocket_publish_message(channel,message): websocket_message = RedisMessage(message) # create a welcome message to be sent to everybody RedisPublisher(facility=channel, broadcast=True).publish_message(websocket_message)
def send_message(self, game, message): facility = 'notify-%s' % game.slug self.stdout.write(' Sending %s [facility=%s]' % (message, facility)) redis_publisher = RedisPublisher(facility=facility, broadcast=True) redis_publisher.publish_message(RedisMessage(message))
def postHeartbeat(self, request, pk=None): global EXPIRATION #check for seperate cache entry """ if (cache.get('heartbeat') != None): #trigger would be 'heartbeat' for status of heartbeats #SEND TRIGGER IN THIS CASE TO START """ if not cache.has_key('heartbeat'): #if doesn't have key heartbeat set its cache entry cache.set('heartbeat', 'connected', EXPIRATION) else: #else delete the old one cache.delete('heartbeat') #create a new one cache.set('heartbeat', 'connected', EXPIRATION) #ONCE STARTS RECEIVING HEARTBEATS #cache.set('heartbeat', 'triggering', EXPIRATION) #ONCE STOPS RECEIVING HEARTBEATS #cache.set('heartbeat','stopped', EXPIRATION) if cache.get('trigger') == 1: redis_publisher = RedisPublisher(facility="viewer", sessions=gcsSessions()) redis_publisher.publish_message( RedisMessage( json.dumps({ 'triggering': 'true', 'time': cache.get("time") }))) elif cache.get('trigger') == 0: redis_publisher = RedisPublisher(facility="viewer", sessions=gcsSessions()) redis_publisher.publish_message( RedisMessage(json.dumps({'triggering': 'false'}))) if (cache.has_key('trigger')): return Response({ 'heartbeat': cache.get('trigger'), 'loop': cache.get('loop'), 'delay': cache.get('delay') }) else: return Response({})
def publish_in_ws(image): data = dict() data["id"] = image.id converted = image.converted_datetime data["created"] = time.mktime(image.created.timetuple()) data["converted_datetime"] = converted and time.mktime(converted.timetuple()) or None msg = RedisMessage(json.dumps(data)) RedisPublisher(facility='foobar', broadcast=True).publish_message(msg)
def publish(object): """ Publish an object to websocket listeners :param object: A Django predictive_model :return: {type: object class name, data: OBJECT} """ message = RedisMessage(_serializer(object)) redis_publisher.publish_message(message)
def notify_file_ready(args): sess, msg = args # simulate hard work time.sleep(1) redis_publisher = RedisPublisher(facility='comm', sessions=[sess]) message = RedisMessage(msg) redis_publisher.publish_message(message) return msg
def broadcast_post(request): redis_publisher = RedisPublisher(facility='foobar', broadcast=True) msg = request.POST.get('message') rip = request.META['REMOTE_ADDR'] message = RedisMessage(rip + ': ' + msg) print msg, ' from ', rip redis_publisher.publish_message(message) return HttpResponse('OK')
def create_notification(assignee, task_title): task = Task.objects.get(title=task_title) user = User.objects.get(pk=assignee) if task: notify = Notification.objects.create(assigned_to=user, notify=task) redis_publisher = RedisPublisher(facility="foobar", broadcast=True) message = RedisMessage("new") redis_publisher.publish_message(message) return True
def publishMessage(topic, message="update", groups=[]): if not groups: redis_publisher = RedisPublisher(facility=topic, broadcast=True) else: redis_publisher = RedisPublisher(facility=topic, groups=groups) message = RedisMessage(message) redis_publisher.publish_message(message)
def connectionCheck(): if cache.has_key("checkallowed"): if not cache.has_key("android"): redis_publisher = RedisPublisher(facility='viewer', sessions=gcsSessions()) redis_publisher.publish_message( RedisMessage(json.dumps({'disconnected': 'disconnected'}))) cache.delete("checkallowed")
def notify_refresh_user(id, name): redis_publisher = RedisPublisher(facility='talk', broadcast=True) message = RedisMessage( json.dumps({ 'op': 'notify_refresh_user', 'id': id, 'name': name })) redis_publisher.publish_message(message) return {'status': 'success'}
def add_to_queue(self, obj): if getattr(settings, 'UNIVERSAL_NOTIFICATIONS_TWILIO_ENABLE_PROXY', False): connection = StrictRedis(**private_settings.WS4REDIS_CONNECTION) r = JSONRenderer() json_data = r.render({'number': obj.from_phone}) channel = getattr(settings, 'UNIVERSAL_NOTIFICATIONS_TWILIO_DISPATCHER_CHANNEL', '__un_twilio_dispatcher') connection.publish(channel, RedisMessage(json_data)) else: self.send(obj.message) obj.message.save()
def UpdateDoc(self, row_data, user): err = {"error": "Input Validation Failed"} if not ValidateUserInput(row_data['comment']).ValidateInputMixed(): return err query = { "doc": { "Record": { "Comment": { "Date": str(datetime.datetime.utcnow()), "Analyst": str(user), "Comment": row_data['comment'] }, "Tag": update_control.TagIntToStr(row_data['tag']) } } } try: r = requests.post(self.es_host + ":" + self.es_port + self.index + self.type_audit_type + '/{0}/_update?parent={1}'.format( row_data['rowId'], row_data['parent']), data=json.dumps(query), auth=(self.elastic_user, self.elastic_pass), verify=False) except ConnectionError as e: ret = {"connection_error": e.args[0]} return ret try: q = requests.get(self.es_host + ":" + self.es_port + self.index + self.type_audit_type + "/{0}?parent={1}".format( row_data['rowId'], row_data['parent']), auth=(self.elastic_user, self.elastic_pass), verify=False) case = q.json()['_source']['CaseInfo']['case_name'] except ConnectionError as e: _ret = {"connection_error": e.args[0]} return _ret redis_publisher = RedisPublisher(facility='comments', broadcast=True) broadcast_comment = { "comment": row_data['comment'], "endpoint": row_data['parent'], "case": case, "analyst": str(user) } redis_publisher.publish_message( RedisMessage(json.dumps(broadcast_comment))) return r.json()
def interop_error_handler(error, startTime): code, reason, text = error.errorData() #response to client accordingly #but keep going...if something fails, respond and ignore it #alert mission planner about the error though if code == 400: return Response({ 'time': time() - startTime, 'error': "WARNING: Invalid telemetry data. Skipping" }) elif code == 404: return Response({ 'time': time() - startTime, 'error': "WARNING: Server might be down" }) elif code == 405 or code == 500: return Response({ 'time': time() - startTime, 'error': "WARNING: Interop Internal Server Error" }) #EXCEPT FOR THIS elif code == 403: creds = cache.get("Creds") times = 5 for i in xrange(0, times): try: interop_login(username=creds['username'], password=creds['password'], server=creds['server'], tout=5) return Response({ 'time': time() - startTime, 'error': "Had to relogin in. Succeeded" }) except Exception as e: sleep(2) continue code, _, __ = e.errorData() #Everyone should be alerted of this resp = { 'time': time() - startTime, 'error': "CRITICAL: Re-login has Failed. We will login again when allowed\nLast Error was %d" % code } redis_publisher = RedisPublisher(facility='viewer', sessions=gcsSessions()) redis_publisher.publish_message( RedisMessage(json.dumps({'warning': resp}))) return Response(resp)
class WebsocketTests(LiveServerTestCase): fixtures = ['data.json'] @classmethod def setUpClass(cls): os.environ.update(DJANGO_LIVE_TEST_SERVER_ADDRESS="localhost:8000-8010,8080,9200-9300") super(WebsocketTests, cls).setUpClass() cls.server_thread.httpd.set_app(application) def setUp(self): self.facility = u'unittest' self.prefix = getattr(settings, 'WS4REDIS_PREFIX', 'ws4redis') self.websocket_base_url = self.live_server_url.replace('http:', 'ws:', 1) + u'/ws/' + self.facility self.message = RedisMessage(''.join(unichr(c) for c in range(33, 128))) self.factory = RequestFactory() # SessionStore # as used here: http://stackoverflow.com/a/7722483/1913888 settings.SESSION_ENGINE = 'redis_sessions.session' engine = import_module(settings.SESSION_ENGINE) store = engine.SessionStore() store.save() self.session = store self.client.cookies[settings.SESSION_COOKIE_NAME] = store.session_key @classmethod def tearDownClass(cls): time.sleep(1) def test_subscribe_broadcast(self): audience = {'broadcast': True} publisher = RedisPublisher(facility=self.facility, **audience) publisher.publish_message(self.message, 10) websocket_url = self.websocket_base_url + u'?subscribe-broadcast' ws = create_connection(websocket_url) self.assertTrue(ws.connected) result = ws.recv() if six.PY3: self.message = self.message.decode() self.assertEqual(result, self.message) ws.close() self.assertFalse(ws.connected) def test_pubsub_broadcast(self): websocket_url = self.websocket_base_url + u'?subscribe-broadcast&publish-broadcast' ws = create_connection(websocket_url) self.assertTrue(ws.connected) ws.send(self.message) result = ws.recv() if six.PY3: self.message = self.message.decode() self.assertEqual(result, self.message) ws.close() self.assertFalse(ws.connected) def test_publish_broadcast(self): websocket_url = self.websocket_base_url + u'?publish-broadcast' ws = create_connection(websocket_url) self.assertTrue(ws.connected) ws.send(self.message) ws.close() self.assertFalse(ws.connected) publisher = RedisPublisher() request = self.factory.get('/chat/') result = publisher.fetch_message(request, self.facility, 'broadcast') self.assertEqual(result, self.message) # now access Redis store directly self.assertEqual(publisher._connection.get(self.prefix + ':broadcast:' + self.facility), self.message) def test_subscribe_user(self): logged_in = self.client.login(username='******', password='******') self.assertTrue(logged_in, 'John is not logged in') request = self.factory.get('/chat/') request.user = User.objects.get(username='******') audience = {'users': ['john', 'mary']} publisher = RedisPublisher(request=request, facility=self.facility, **audience) publisher.publish_message(self.message, 10) websocket_url = self.websocket_base_url + u'?subscribe-user' header = ['Cookie: sessionid={0}'.format(self.client.cookies['sessionid'].coded_value)] ws = create_connection(websocket_url, header=header) self.assertTrue(ws.connected) result = ws.recv() if six.PY3: self.message = self.message.decode() self.assertEqual(result, self.message) ws.close() self.assertFalse(ws.connected) def test_publish_user(self): logged_in = self.client.login(username='******', password='******') self.assertTrue(logged_in, 'John is not logged in') websocket_url = self.websocket_base_url + u'?publish-user' header = ['Cookie: sessionid={0}'.format(self.client.cookies['sessionid'].coded_value)] ws = create_connection(websocket_url, header=header) self.assertTrue(ws.connected) ws.send(self.message) ws.close() self.assertFalse(ws.connected) publisher = RedisPublisher() request = self.factory.get('/chat/') request.user = User.objects.get(username='******') result = publisher.fetch_message(request, self.facility, 'user') self.assertEqual(result, self.message) request.user = None result = publisher.fetch_message(request, self.facility, 'user') self.assertEqual(result, None) def test_subscribe_group(self): logged_in = self.client.login(username='******', password='******') self.assertTrue(logged_in, 'John is not logged in') request = self.factory.get('/chat/') request.user = User.objects.get(username='******') audience = {'groups': ['chatters']} publisher = RedisPublisher(request=request, facility=self.facility, **audience) publisher.publish_message(self.message, 10) websocket_url = self.websocket_base_url + u'?subscribe-group' header = ['Cookie: sessionid={0}'.format(self.client.cookies['sessionid'].coded_value)] ws = create_connection(websocket_url, header=header) self.assertTrue(ws.connected) result = ws.recv() if six.PY3: self.message = self.message.decode() self.assertEqual(result, self.message) ws.close() self.assertFalse(ws.connected) def test_publish_group(self): logged_in = self.client.login(username='******', password='******') self.assertTrue(logged_in, 'John is not logged in') websocket_url = self.websocket_base_url + u'?publish-group' header = ['Cookie: sessionid={0}'.format(self.client.cookies['sessionid'].coded_value)] ws = create_connection(websocket_url, header=header) self.assertTrue(ws.connected) ws.send(self.message) ws.close() self.assertFalse(ws.connected) publisher = RedisPublisher() request = self.factory.get('/chat/') request.user = User.objects.get(username='******') logged_in = self.client.login(username='******', password='******') self.assertTrue(logged_in, 'Mary is not logged in') request.session = self.client.session result = publisher.fetch_message(request, self.facility, 'group') self.assertEqual(result, self.message) def test_subscribe_session(self): logged_in = self.client.login(username='******', password='******') self.assertTrue(logged_in, 'John is not logged in') self.assertIsInstance(self.client.session, (dict, type(self.session)), 'Did not receive a session key') session_key = self.client.session.session_key self.assertGreater(len(session_key), 30, 'Session key is too short') request = self.factory.get('/chat/') request.session = self.client.session audience = {'sessions': [SELF]} publisher = RedisPublisher(request=request, facility=self.facility, **audience) publisher.publish_message(self.message, 10) websocket_url = self.websocket_base_url + u'?subscribe-session' header = ['Cookie: sessionid={0}'.format(session_key)] ws = create_connection(websocket_url, header=header) self.assertTrue(ws.connected) result = ws.recv() if six.PY3: self.message = self.message.decode() self.assertEqual(result, self.message) ws.close() self.assertFalse(ws.connected) def test_publish_session(self): logged_in = self.client.login(username='******', password='******') self.assertTrue(logged_in, 'Mary is not logged in') self.assertIsInstance(self.client.session, (dict, type(self.session)), 'Did not receive a session key') session_key = self.client.session.session_key self.assertGreater(len(session_key), 30, 'Session key is too short') websocket_url = self.websocket_base_url + u'?publish-session' header = ['Cookie: sessionid={0}'.format(session_key)] ws = create_connection(websocket_url, header=header) self.assertTrue(ws.connected) ws.send(self.message) ws.close() self.assertFalse(ws.connected) publisher = RedisPublisher() request = self.factory.get('/chat/') request.session = self.client.session result = publisher.fetch_message(request, self.facility, 'session') self.assertEqual(result, self.message) def test_invalid_request(self): websocket_url = self.live_server_url + u'/ws/foobar' response = requests.get(websocket_url) self.assertEqual(response.status_code, 400) content = response.content if six.PY3: content = content.decode() self.assertIn('upgrade to a websocket', content) response = requests.post(websocket_url, {}) self.assertEqual(response.status_code, 400) def t_e_s_t_invalid_version(self): # does not work: websocket library overrides Sec-WebSocket-Version websocket_url = self.websocket_base_url + u'?publish-broadcast' header = ['Sec-WebSocket-Version: 6'] # Version 6 is not supported ws = create_connection(websocket_url, header=header) self.assertFalse(ws.connected) def test_defining_multiple_publishers(self): pub1 = RedisPublisher(facility=self.facility, broadcast=True) self.assertEqual(pub1._publishers, set([self.prefix + ':broadcast:' + self.facility])) pub2 = RedisPublisher(facility=self.facility, users=['john']) self.assertEqual(pub2._publishers, set([self.prefix + ':user:john:' + self.facility])) def test_forbidden_channel(self): websocket_url = self.websocket_base_url + u'?subscribe-broadcast&publish-broadcast' try: create_connection(websocket_url, header=['Deny-Channels: YES']) self.fail('Did not reject channels') except WebSocketException: self.assertTrue(True) def test_close_connection(self): class Counter: def __init__(self): self.value = 0 counter = Counter() old_handle_error = WSGIServer.handle_error def handle_error(self, *args, **kwargs): # we need a reference to an object for this to work not a simple variable counter.value += 1 return old_handle_error(self, *args, **kwargs) WSGIServer.handle_error = handle_error statuses = [1000, 1001, 1002, 1003, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1015, ] websocket_url = self.websocket_base_url + u'?subscribe-broadcast&publish-broadcast' for status in statuses: value_before = counter.value ws = create_connection(websocket_url) self.assertTrue(ws.connected) ws.close(status) self.assertFalse(ws.connected) self.assertEqual(value_before, counter.value, 'Connection error while closing with {}'.format(status)) def test_protocol_support(self): protocol = 'unittestprotocol' websocket_url = self.websocket_base_url + u'?subscribe-broadcast&publish-broadcast' ws = create_connection(websocket_url, subprotocols=[protocol]) self.assertTrue(ws.connected) self.assertIn('sec-websocket-protocol', ws.headers) self.assertEqual(protocol, ws.headers['sec-websocket-protocol']) ws.close() self.assertFalse(ws.connected)