realtime_web Commit - r2:ccdf3a6b9025

Reorganize models, smaller docker, others

jespinoza -

r2:ccdf3a6b9025

parent child

Context file:

r2:ccdf3a6b9025

Collapse all files

scripts/experiments.json created 644 +110 0

@@ -0,0 +1,110
	1	[
	2	{
	3	"code" : 100,
	4	"name" : "HF JRO"
	5	},
	6	{
	7	"code" : 101,
	8	"name" : "HF Huancayo"
	9	},
	10	{
	11	"code" : 102,
	12	"name" : "HF Ica"
	13	},
	14	{
	15	"code" : 110,
	16	"name" : "ISR EW Drifts"
	17	},
	18	{
	19	"code" : 111,
	20	"name" : "ISR Faraday"
	21	},
	22	{
	23	"code" : 112,
	24	"name" : "ISR Imaging"
	25	},
	26	{
	27	"code" : 120,
	28	"name" : "Faraday"
	29	},
	30	{
	31	"code" : 121,
	32	"name" : "Faraday Long Pulse"
	33	},
	34	{
	35	"code" : 122,
	36	"name" : "Faraday Codded LP"
	37	},
	38	{
	39	"code" : 123,
	40	"name" : "Faraday Double Pulse"
	41	},
	42	{
	43	"code" : 124,
	44	"name" : "Faraday AC"
	45	},
	46	{
	47	"code" : 125,
	48	"name" : "Faraday Differential Phase"
	49	},
	50	{
	51	"code" : 150,
	52	"name" : "JASMET 50"
	53	},
	54	{
	55	"code" : 151,
	56	"name" : "JASMET 30"
	57	},
	58	{
	59	"code" : 170,
	60	"name" : "BLTR Huancayo"
	61	},
	62	{
	63	"code" : 171,
	64	"name" : "CIRI Huancayo"
	65	},
	66	{
	67	"code" : 172,
	68	"name" : "CLAIRE Huancayo"
	69	},
	70	{
	71	"code" : 180,
	72	"name" : "MST"
	73	},
	74	{
	75	"code" : 181,
	76	"name" : "ISR"
	77	},
	78	{
	79	"code" : 182,
	80	"name" : "EEJ"
	81	},
	82	{
	83	"code" : 190,
	84	"name" : "JULIA 150km (Natalia)"
	85	},
	86	{
	87	"code" : 191,
	88	"name" : "JULIA SpreadF (Natalia)"
	89	},
	90	{
	91	"code" : 200,
	92	"name" : "JULIA 150km"
	93	},
	94	{
	95	"code" : 201,
	96	"name" : "JULIA EEJ"
	97	},
	98	{
	99	"code" : 202,
	100	"name" : "JULIA SpreadF"
	101	},
	102	{
	103	"code" : 203,
	104	"name" : "JULIA Imaging"
	105	},
	106	{
	107	"code" : 203,
	108	"name" : "JULIA Bistatic"
	109	}
	110	] No newline at end of file

Dockerfile 0 0

NO CONTENT: modified file

docker-compose.yml +1 -1

             version: '2'
             services:
               web:
                 container_name: 'realtime_web'
                 build: .
                 image: realtime
                 command: python manage.py runserver 0.0.0.0:8000
                 env_file: .env
                 ports:
                   - "8000:8000"
                 links:
                   - redis
                   - mongo
                 volumes:
                   - './:/app'
                 depends_on:
                   - redis
                   - mongo
               zmq_server:
                 container_name: 'zmq_server'
                 image: 'realtime'
                 ports:
-                  - '127.0.0.1:4444:4444'
+                  - '4444:4444'
                 command: 'python -u scripts/server.py'
                 env_file: .env
                 links:
                   - redis
                   - mongo
                 volumes:
                   - './:/app'
                 depends_on:
                   - web
               redis:
                 container_name: 'redis'
                 image: 'redis:3.2-alpine'
                 ports:
                   - '127.0.0.1:6379:6379'
                 volumes:
                   - 'redisdata:/data'
               mongo:
                 container_name: 'mongo'
                 image: 'mongo:3.3'
                 command: '--storageEngine wiredTiger'
                 ports:
                   - '127.0.0.1:27017:27017'
                 volumes:
                   - 'mongodata:/data/db'
             volumes:
               redisdata:
               mongodata:

plotter/consumers.py +21 -20

             import os
             import json
-            import numpy as np
             from datetime import datetime
             from pymongo import MongoClient
-            from models import Experiment, Data
             from channels.handler import AsgiHandler
             from channels.auth import channel_session_user
             from channels import Group
             host = os.environ.get('HOST_MONGO', 'localhost')
             CLIENT = MongoClient('{}:27017'.format(host))
             DB = CLIENT['dbplots']
             # Connected to websocket.connect
             def ws_connect(message, code, plot):
-                # Accept the incoming connection
                 message.reply_channel.send({'accept': True})
-                # Add them to the chat group
+                pk = message.content['query_string'].split('=')[1]
-                Group('{}_{}'.format(code, plot)).add(message.reply_channel)
+                Group('{}_{}'.format(pk, plot)).add(message.reply_channel)
+                print('New connection from: {}, creating Group: {}_{}'.format(message.content['client'][0], pk, plot))
             def ws_message(message, code, plot):
                 # Accept the incoming connection
+                print 'incoming message'
                 dt = datetime.strptime(str(json.loads(message.content['text'])['date']), '%d/%m/%Y')
-                e = DB.experiment.find_one({'date': dt})
+                exp = DB.exp_meta.find_one({'code': int(code), 'date': dt})
-                if e:
+                print exp
+                if exp:
                     if plot == 'spc':
-                        datas = DB.data.find({'experiment': e['_id']}, ['time', 'data']).sort('time', -1).limit(1)[0]
+                        datas = DB.exp_data.find({'expmeta': exp['_id']}, ['time', 'data']).sort('time', -1).limit(1)[0]
-                        e['time'] = [datas['time']]
+                        exp['time'] = [datas['time']]
-                        e['spc'] = datas['data']['spc']
+                        exp['spc'] = datas['data']['spc']
-                        e['rti'] = datas['data']['rti']
+                        exp['rti'] = datas['data']['rti']
-                        e['noise'] = datas['data']['noise']
+                        exp['noise'] = datas['data']['noise']
                     else:
-                        datas = DB.data.find({'experiment': e['_id']}, ['time', 'data']).sort('time', 1)
+                        datas = DB.exp_data.find({'expmeta': exp['_id']}, ['time', 'data']).sort('time', 1)
+                        print 'Counting...'
+                        print datas.count()
                         dum = [(d['time'], d['data'][plot]) for d in datas]
-                        e['time'] = [d[0] for d in dum]
+                        exp['time'] = [d[0] for d in dum]
                         dum = [d[1] for d in dum]
-                        e[plot] = map(list, zip(*dum))
+                        exp[plot] = map(list, zip(*dum))
-                    e.pop('date', None)
+                    exp.pop('date', None)
-                    e.pop('_id', None)
+                    exp.pop('_id', None)
-                    message.reply_channel.send({'text': json.dumps(e)})
+                    message.reply_channel.send({'text': json.dumps(exp)})
                 else:
                     message.reply_channel.send({'text': json.dumps({'interval': 0})})
             # Connected to websocket.disconnect
             def ws_disconnect(message, code, plot):
                 Group('{}_{}'.format(code, plot)).discard(message.reply_channel)

plotter/models.py +8 -6

             # -*- coding: utf-8 -*-
             from __future__ import unicode_literals
             from django.db import models
             from mongoengine import *
             class Experiment(Document):
+                code = IntField(unique=True)
+                name = StringField(max_length=40)
+            class ExpMeta(Document):
                 code = IntField()
-                name = StringField(max_length=40, default='Experiment')
                 date = DateTimeField()
                 pairs = ListField(default=list)
                 yrange = ListField(FloatField())
                 xrange = ListField(FloatField())
                 interval = FloatField()
+                plots = ListField(StringField())
                 localtime = BooleanField()
                 meta = {
                     'indexes': [[("code", 1), ("date", 1)]]
                 }
-            class Data(Document):
+            class ExpData(Document):
-                experiment = LazyReferenceField(Experiment)
+                expmeta = LazyReferenceField(ExpMeta)
                 time = FloatField()
                 data = DictField()
                 meta = {
-                    'indexes': ["experiment", "+time"]
+                    'indexes': ["expmeta", "+time"]
                 }
-            # connect('dbplots')
-            # Experiment.drop_collection()

plotter/static/js/jroplots.js +1 -1

             class PcolorBuffer{
                 constructor({div, data, key, props}){
                     this.div = document.getElementById(div);
                     this.n = 0
                     this.divs = [];
                     this.wait = false;
                     this.key = key;
                     this.timer = (props.throttle || 30)*1000;
                     this.lastRan = Date.now();
                     this.lastFunc = null;
                     this.zbuffer = [];
                     this.xbuffer = [];
                     this.empty = Array(data.yrange.length).fill(null);
                     this.props = props;
                     this.setup(data);
                 }
                 setup(data){
                     this.last = data.time.slice(-1);
                     if (data.time.length == 1){
                         var values = { 'time': data.time, 'data': data[this.key].map(function(x) {return [x]})};
                     }else{
                         var values = this.fill_gaps(data.time, data[this.key], data.interval, data[this.key].length);
                     }
                     var t = values.time.map(function(x) { return new Date(x*1000); });
                     for (var i = 0; i < data[this.key].length; i++){
                         var layout = {
                             xaxis: {
                               title: 'Time',
                               showgrid: false,
                             },
                             yaxis: {
                               title: 'km',
                               showgrid: false,
                             },
                             titlefont: {
                                 size: 14,
                             }
                         };
                         var iDiv = document.createElement('div');
                         iDiv.id = 'plot-' + i;
                         this.zbuffer.push([]);
                         this.n = this.n + 1;
                         this.div.appendChild(iDiv);
                         this.divs.push(iDiv.id);
                         var trace = {
                             z: values.data[i],
                             x: t,
                             y: data.yrange,
                             colorscale: this.props.colormap || 'Viridis',
                             transpose: true,
                             type: 'heatmap'
                         };
                         if (this.props.zmin) {trace.zmin = this.props.zmin}
                         if (this.props.zmax) {trace.zmax = this.props.zmax}
                         layout.title = 'Channel ' + i + ' - ' + t.slice(-1).toLocaleString();
                         var conf = {
                             modeBarButtonsToRemove: ['sendDataToCloud', 'autoScale2d', 'hoverClosestCartesian', 'hoverCompareCartesian', 'lasso2d', 'select2d', 'zoomIn2d', 'zoomOut2d', 'toggleSpikelines'],
                             displaylogo: false,
                             showTips: true
                         };
                         Plotly.newPlot('plot-'+i, [trace], layout, conf);
                     }
                 }
                 getSize(){
                     var div = document.getElementById(this.divs[0]);
                     var t = this.xbuffer.slice(-1)[0];
                     var n = 0;
                     var timespan = (this.props.timespan || 8)*1000*60*60;
                     while ((t-div.data[0].x[n]) > timespan){
                         n += 1;
                     }
                     return n;
                 }
                 fill_gaps(xBuffer, zBuffer, interval, N){
                     var x = [xBuffer[0]];
                     var z = [];
                     var last;
                     for (var j = 0; j < N; j++){
                         z.push([zBuffer[j][0]]);
                     }
                     for (var i = 1; i < xBuffer.length; i++){
                         var cnt = 0;
                         last = x.slice(-1)[0];
                         while (Math.abs(parseFloat(xBuffer[i])-last-parseFloat(interval))>0.5){
                             cnt += 1;
                             last = last+interval;
                             x.push(last);
                             for (var j = 0; j < N; j++){
                                 z[j].push(this.empty);
                             }
                             // Avoid infinite loop
                             if (cnt==100){break;}
                         }
                         x.push(xBuffer[i]);
                         for (var j = 0; j < N; j++){
                             z[j].push(zBuffer[j][i]);
                         }
                     }
                     return {'time':x, 'data':z};
                 }
                 plot(){
                     // add new data to plots and empty buffers
                     var N = this.getSize();
                     console.log('Plotting...');
                     for (var i = 0; i < this.n; i++){
                         var div = document.getElementById(this.divs[i]);
                         if (N > 0){
                             div.data[0].z = div.data[0].z.slice(N,)
                             div.data[0].x = div.data[0].x.slice(N,)
                         }
                         Plotly.extendTraces(div, {
                             z: [this.zbuffer[i]],
                             x: [this.xbuffer]
                         }, [0]);
                         this.zbuffer[i] = [];
                     }
                     this.xbuffer = [];
                 }
                 update(obj){
                     // fill data gaps
                     var cnt = 0;
                     while (Math.abs(parseFloat(obj.time[0])-this.last-parseFloat(obj.interval))>0.5){
                         cnt += 1;
                         this.last += obj.interval;
                         var newt = new Date((this.last)*1000);
                         this.xbuffer.push(newt);
                         for (var i = 0; i < obj[this.key].length; i++){
                             this.zbuffer[i].push(this.empty);
                         }
                         // Avoid infinite loop
                         if (cnt==100){break;}
                     }
                     // update buffers
                     this.last = parseFloat(obj.time[0]);
                     var t = new Date(obj.time[0]*1000);
                     this.xbuffer.push(t);
                     for (var i = 0; i < obj[this.key].length; i++){
                         this.zbuffer[i].push(obj[this.key][i]);
                         // update title
                         var div = document.getElementById(this.divs[i]);
                         Plotly.relayout(div, {
                             title: 'Channel ' + i + ' - ' + t.toLocaleString(),
                         });
                     }
                     // plot when ready (every 10 secs)
                     if (!this.wait){
                         this.plot();
                         this.wait = true;
                     } else {
                         clearTimeout(this.lastFunc)
                         this.lastFunc = setTimeout(function(scope) {
                             if ((Date.now() - scope.lastRan) >= scope.timer) {
                               scope.plot()
                               scope.lastRan = Date.now()
                             }
                           }, this.timer - (Date.now() - this.lastRan), this)
                     }
                 }
             }
             class Pcolor{
                 constructor({div, data, props}){
                     this.div = document.getElementById(div);
                     this.n = 0
                     this.divs = [];
                     this.props = props;
                     this.setup(data);
                 }
                 setup(data){
                     console.log(data);
                     for (var i = 0; i < data.spc.length; i++){
                         var layout = {
                             height: 400,
                             xaxis: {
                               title: 'Velocity',
                               showgrid: false,
                               zeroline: false,
                               domain: [0, 0.7],
                             },
                             yaxis: {
                               title: 'km',
                               showgrid: false,
                             },
                             xaxis2: {
                                 title: 'dB',
                                 domain: [0.75, 1],
                                 ticks: 'outside',
                               },
                             titlefont: {
                                 size: 14,
                             }
                         };
                         var iDiv = document.createElement('div');
                         iDiv.id = 'plot-' + i;
                         iDiv.className += iDiv.className ? ' col-md-6' : 'col-md-6';
                         this.n = this.n + 1;
                         this.div.appendChild(iDiv);
                         this.divs.push(iDiv.id);
                         var trace1 = {
                             z: data.spc[i],
                             x: data.xrange,
                             y: data.yrange,
                             colorscale: this.props.colormap || 'Viridis',
                             transpose: true,
                             type: 'heatmap'
                         };
                         var trace2 = {
                             x: data.rti[i],
                             y: data.yrange,
                             xaxis: 'x2',
                             yaxis: 'y',
                             type: 'scatter',
                         };
                         if (this.props.zmin) {
                             trace1.zmin = this.props.zmin
                         }
                         if (this.props.zmax) {
                             trace1.zmax = this.props.zmax;
                             layout.xaxis2.range = [this.props.zmin, this.props.zmax]
                         }
                         var t = new Date(data.time*1000);
                         layout.title = 'Channel ' + i + ': ' + data.noise[i]+'dB - ' + t.toLocaleString();
                         var conf = {
                             modeBarButtonsToRemove: ['sendDataToCloud', 'autoScale2d', 'hoverClosestCartesian', 'hoverCompareCartesian', 'lasso2d', 'select2d', 'zoomIn2d', 'zoomOut2d', 'toggleSpikelines'],
                             displaylogo: false,
                             showTips: true
                         };
                         Plotly.newPlot('plot-'+i, [trace1, trace2], layout, conf);
                     }
                 }
                 plot(obj){
                     // add new data to plots and empty buffers
                     console.log('Plotting...');
                     var t = new Date(obj.time[0]*1000);
                     for (var i = 0; i < this.n; i++){
                         var div = document.getElementById(this.divs[i]);
                         Plotly.relayout(div, {
                             title: 'Channel ' + i + ': ' + obj.noise[i]+'dB - ' + t.toLocaleString(),
                         });
                         Plotly.restyle(div, {
                             z: [obj.spc[i], null],
                             x: [obj.xrange, obj.rti[i]]
                         }, [0, 1]);
                     }
                 }
             }
             class Scatter{
                 constructor({div, data, key, props}){
                     this.div = document.getElementById(div);
                     this.n = 0
                     this.key = key;
                     this.wait = false;
                     this.timer = (props.throttle || 30)*1000;
                     this.lastRan = Date.now();
                     this.lastFunc = null;
                     this.ybuffer = [];
                     this.xbuffer = [];
                     this.props = props;
                     this.setup(data);
                 }
                 setup(data){
                     var traces = [];
                     this.last = data.time.slice(-1);
                     if (data.time.length == 1){
                         var values = { 'time': data.time, 'data': data[this.key] };
                     }else{
                         var values = this.fill_gaps(data.time, data[this.key], data.interval, data[this.key].length);
                     }
                     var t = values.time.map(function(x) { return new Date(x*1000); });
                     for (var i = 0; i < data[this.key].length; i++){
                         this.n = this.n + 1;
                         this.ybuffer.push([]);
                         var trace = {
                             x: t,
                             y: data[this.key][i],
                             mode: 'lines',
                             type: 'scatter',
                             name: 'Channel ' + i
                         };
                         traces.push(trace);
                     }
                     var title = this.props.title || ''
                     var layout = {
                         // autosize: false,
                         // width: 800,
                         // height: 400,
                         title: title + ' - ' + t.slice(-1).toLocaleString(),
                         xaxis: {
                           title: 'Time',
                           linecolor: 'black',
                         },
                         yaxis: {
                           title: this.props.ylabel || 'dB',
                           linecolor: 'black',
                         },
                         titlefont: {
                             size: 14,
                         }
                     };
                     if (this.props.ymin) {layout.yaxis.range = [this.props.ymin, this.props.ymax] }
                     var conf = {
                         modeBarButtonsToRemove: ['sendDataToCloud', 'autoScale2d', 'hoverClosestCartesian', 'hoverCompareCartesian', 'lasso2d', 'select2d', 'zoomIn2d', 'zoomOut2d', 'toggleSpikelines'],
                         displaylogo: false,
                         showTips: true
                     };
                     Plotly.newPlot('plot', traces, layout, conf);
                 }
                 getSize(){
                     var t = this.xbuffer.slice(-1)[0];
                     var n = 0;
                     var timespan = (this.props.timespan || 12)*1000*60*60;
                     while ((t-this.div.data[0].x[n]) > timespan){
                         n += 1;
                     }
                     return n;
                 }
                 fill_gaps(xBuffer, yBuffer, interval, N){
                     var x = [xBuffer[0]];
                     var y = [];
                     for (var j = 0; j < N; j++){
                         y.push([yBuffer[j][0]]);
                     }
                     var last;
                     for (var i = 1; i < xBuffer.length; i++){
                         var cnt = 0;
                         last = x.slice(-1)[0];
                         while (Math.abs(parseFloat(xBuffer[i])-last-parseFloat(interval))>0.5){
                             cnt += 1;
                             last = last+interval;
                             x.push(last);
                             for (var j = 0; j < N; j++){
-                                z[j].push(null);
+                                y[j].push(null);
                             }
                             // Avoid infinite loop
                             if (cnt==100){break;}
                         }
                         x.push(xBuffer[i]);
                         for (var j = 0; j < N; j++){
                             y[j].push(yBuffer[j][i]);
                         }
                     }
                     return {'time':x, 'data':y};
                 }
                 plot(){
                     // add new data to plots and empty buffers
                     var xvalues = [];
                     var yvalues = [];
                     var traces = [];
                     var N = this.getSize();
                     console.log('Plotting...');
                     for (var i = 0; i < this.n; i++){
                         if (N > 0){
                             this.div.data[i].y = this.div.data[i].y.slice(N,)
                             this.div.data[i].x = this.div.data[i].x.slice(N,)
                         }
                         yvalues.push(this.ybuffer[i]);
                         xvalues.push(this.xbuffer);
                         traces.push(i);
                         this.ybuffer[i] = [];
                     }
                     Plotly.extendTraces(this.div, {
                         y: yvalues,
                         x: xvalues
                     }, traces);
                     this.xbuffer = [];
                 }
                 update(obj){
                     // fill data gaps
                     var cnt = 0;
                     while (Math.abs(parseFloat(obj.time[0])-this.last-parseFloat(obj.interval))>0.5){
                         cnt += 1;
                         this.last += obj.interval;
                         var newt = new Date((this.last)*1000);
                         this.xbuffer.push(newt);
                         for (var i = 0; i < this.n; i++){
                             this.ybuffer[i].push(null);
                         }
                         // Avoid infinite loop
                         if (cnt==100){break;}
                     }
                     // update buffers
                     this.last = parseFloat(obj.time[0]);
                     var t = new Date(obj.time[0]*1000);
                     this.xbuffer.push(t);
                     for (var i = 0; i < this.n; i++){
                         this.ybuffer[i].push(obj[this.key][i][0]);
                     }
                     var title = this.props.title || ''
                     Plotly.relayout(this.div, {
                         title: title + ' - ' + t.toLocaleString(),
                     });
                     // plot when ready (every 10 secs)
                     if (!this.wait){
                         this.plot();
                         this.wait = true;
                     } else {
                         clearTimeout(this.lastFunc)
                         this.lastFunc = setTimeout(function(scope) {
                             if ((Date.now() - scope.lastRan) >= scope.timer) {
                               scope.plot()
                               scope.lastRan = Date.now()
                             }
                           }, this.timer - (Date.now() - this.lastRan), this)
                     }
                 }
             }

plotter/templates/base.html +7 -1

             {% load static %} {% load bootstrap3 %}
             <!doctype html>
             <html lang="en">
             <head>
               <meta charset="utf-8">
               <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
               <meta http-equiv="X-UA-Compatible" content="ie=edge">
               <link href="//maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
               <link href="{% static 'css/bootstrap-datetimepicker.min.css' %}" media="screen" rel="stylesheet">
               <script src="{% static 'js/jquery.min.js' %}"></script>
               <style>
                 /* Paste this css to your style sheet file or under head tag */
                 /* This only works with JavaScript,
                   if it's not present, don't show loader */
                 .loader {
                   width: 100%;
                   height: 10px;
                   position: relative;
                   z-index: 9999;
                   background: url("{% static 'images/loader.gif' %}") center no-repeat #fff;
                 }
                 .no-data {
                   text-align: center;
                   background-color: #d58512;
                   padding: 8px 16px;
                   border-radius: 5px;
                   color: #FEFEFE;
                   font: 20px 'Helvetica';
                   text-transform: uppercase;
                 }
               </style>
               <title>Realtime plots at JRO</title>
             </head>
             <body>
               <div class="container">
                 <div id="page" class="row" style="min-height:600px">
                   {% bootstrap_messages %}
                   <div class="page-header">
                     <h1>{% block content-title %}Realtime{% endblock %}
                       <small>{% block content-suptitle %}Plots{% endblock %}</small>
                     </h1>
                   </div>
                   <div class="col-md-3 hidden-xs hidden-sm" role="complementary">
                     <div id="sidebar">
                       {% if form.is_multipart %}
                       <form class="form" enctype="multipart/form-data" method="post" action="{{action}}">
                         {% else %}
                         <form class="form" method="post" action="{{action}}">
                           {% endif %} {% csrf_token %} {% bootstrap_form form layout='inline' size='medium' %}
                           <div style="clear: both;"></div>
                           <br>
                           <div class="pull-left">
                             <button type="button" id="bt_show" class="btn btn-primary">Show</button>
                           </div>
                         </form>
                     </div>
                   </div>
                   <div class="col-md-9 col-xs-12" role="main">
                     <div id="loader" class="loader"></div>
                     {% block content %} {% endblock %}
                   </div>
                 </div>
                 <!--/row-->
               </div>
               <script src="{% static 'js/plotly-latest.min.js' %}"></script>
               <script src="{% static 'js/moment.min.js' %}"></script>
               <script src="{% static 'js/bootstrap-datetimepicker.min.js' %}"></script>
               <script src="{% static 'js/jroplots.js' %}"></script>
               <script type="text/javascript">
                 $('#id_date').datetimepicker({
                   pickTime: false,
                   format: 'DD/MM/YYYY',
                 });
                 $("#bt_show").click(function () {
                   document.location = '/' + $("#id_experiment").val() + '/' + $("#id_plot").val() + '/?date=' + $("#id_date").val();
                 });
-                var socket = new WebSocket('ws://' + window.location.host + '/{{code}}/{{plot}}/');
+                {% if date %}
+                $("#loader").css("display", "block");
+                var socket = new WebSocket('ws://' + window.location.host + '/{{code}}/{{plot}}/?' + 'pk={{id}}');
                 socket.onopen = function open() {
                   console.log('WebSockets connection created.');
                   {% if date %}
                   socket.send('{"date": "{{date}}" }');
                   {% else %}
                   socket.send('{"date": "{% now "d/m/Y" %}" }');
                   {% endif %}
                 };
                 socket.onmessage = function message(event) {
                   var data = JSON.parse(event.data);
+                  console.log(data);
                   if (data.interval == 0) {
                     $("#loader").removeClass("loader").addClass("no-data");
                     $("#loader").html("No data found");
                   } else {
                     var first = plot(data);
                     if (first == true) {
                       $("#loader").css("display", "none");
                     }
                   }
                 }
                 if (socket.readyState == WebSocket.OPEN) {
                   socket.onopen();
                 }
+                {% else %}
+                $("#loader").css("display", "none");
+                {% endif %}
               </script> {% block script %}{% endblock script %}
             </body>
             </html>

plotter/views.py +17 -14

             # -*- coding: utf-8 -*-
             from __future__ import unicode_literals
             import os
             from datetime import datetime
             from django import forms
             from django.contrib import messages
             from django.utils.safestring import mark_safe
             from django.shortcuts import render
             from bootstrap3_datetime.widgets import DateTimePicker
-            from pymongo import MongoClient
+            import mongoengine
-            host = os.environ.get('HOST_MONGO', 'localhost')
+            from plotter.models import Experiment, ExpMeta
-            CLIENT = MongoClient('{}:27017'.format(host))
+            host = os.environ.get('HOST_MONGO', 'localhost')
-            DB = CLIENT['dbplots']
+            mongoengine.connect('dbplots', host=host, port=27017)
             # Forms
             class SearchForm(forms.Form):
                 experiment = forms.ChoiceField()
                 plot = forms.ChoiceField(
                     choices = [(0, 'Select Plot'), ('rti', 'RTI'),('spc', 'Spectra'),('noise', 'Noise')]
                 )
                 date = forms.DateField(
                       widget=DateTimePicker(options={"format": "DD/MM/YYYY"})
                       )
                 def __init__(self, *args, **kwargs):
                     exp_choices = kwargs.pop('exp_choices', [])
                     super(SearchForm, self).__init__(*args, **kwargs)
                     self.fields['experiment'].choices = [(0, 'Select Experiment')] + exp_choices
             # Create your views here.
             def main(request, code=None, plot=None):
                 initial = {}
                 date = request.GET.get('date', datetime.now().strftime('%d/%m/%Y'))
                 initial['date'] = date
                 if code is not None:
                     initial['experiment'] = code
                 if plot is not None:
                     initial['plot'] = plot
-                print 'hola'
+                exps = [(q['code'], q['name']) for q in Experiment.objects.all()]
-                codes = DB.experiment.find().distinct('code')
-                print codes
-                exps = [DB.experiment.find_one({'code': c}, ['name']) for c in codes]
-                print exps
-                names = [q['name'] for q in exps]
-                print names
                 form = SearchForm(
                     initial = initial,
-                    exp_choices = [(e[0], e[1]) for e in zip(codes, names)]
+                    exp_choices = [(e[0], e[1]) for e in exps]
                 )
+                try:
+                    exp = ExpMeta.objects.get(code=int(code), date=datetime.strptime(date, '%d/%m/%Y'))
+                    exp_id = exp.id
+                except:
+                    exp_id = 0
                 kwargs = {
                     'code': code,
                     'plot': plot,
                     'date': date,
                     'form': form,
+                    'id': exp_id
                 }
-                if code and codes:
+                if code and exps:
-                    kwargs['title'] = [t[1] for t in zip(codes, names) if t[0]==int(code)][0]
+                    kwargs['title'] = [t[1] for t in exps if t[0]==int(code)][0]
                 else:
                     kwargs['title'] = 'JRO'
                 if plot == 'rti':
                     return render(request, 'rti.html', kwargs)
                 elif plot == 'spc':
                     return render(request, 'spectra.html', kwargs)
                 elif plot == 'noise':
                     return render(request, 'scatter.html', kwargs)
                 else:
                     return render(request, 'base.html', kwargs)

realtime/routing.py 0 0

NO CONTENT: modified file

realtime/settings.py +1 -1

             """
             Django settings for realtime project.
             Generated by 'django-admin startproject' using Django 1.11.7.
             For more information on this file, see
             https://docs.djangoproject.com/en/1.11/topics/settings/
             For the full list of settings and their values, see
             https://docs.djangoproject.com/en/1.11/ref/settings/
             """
             import os
             # Build paths inside the project like this: os.path.join(BASE_DIR, ...)
             BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
             # Quick-start development settings - unsuitable for production
             # See https://docs.djangoproject.com/en/1.11/howto/deployment/checklist/
             # SECURITY WARNING: keep the secret key used in production secret!
             SECRET_KEY = '(htjox+v27sda)$61vjhuveeh_q$gw5+z^cn71!h2m-!!s!7ra'
             # SECURITY WARNING: don't run with debug turned on in production!
             DEBUG = True
             ALLOWED_HOSTS = ['*']
             # Application definition
             INSTALLED_APPS = [
                 'django.contrib.admin',
                 'django.contrib.auth',
                 'django.contrib.contenttypes',
                 'django.contrib.sessions',
                 'django.contrib.messages',
                 'django.contrib.staticfiles',
                 'bootstrap3',
                 'channels',
                 'plotter',
             ]
             MIDDLEWARE = [
                 'django.middleware.security.SecurityMiddleware',
                 'django.contrib.sessions.middleware.SessionMiddleware',
                 'django.middleware.common.CommonMiddleware',
                 'django.middleware.csrf.CsrfViewMiddleware',
                 'django.contrib.auth.middleware.AuthenticationMiddleware',
                 'django.contrib.messages.middleware.MessageMiddleware',
                 'django.middleware.clickjacking.XFrameOptionsMiddleware',
             ]
             ROOT_URLCONF = 'realtime.urls'
             TEMPLATES = [
                 {
                     'BACKEND': 'django.template.backends.django.DjangoTemplates',
                     'DIRS': [],
                     'APP_DIRS': True,
                     'OPTIONS': {
                         'context_processors': [
                             'django.template.context_processors.debug',
                             'django.template.context_processors.request',
                             'django.contrib.auth.context_processors.auth',
                             'django.contrib.messages.context_processors.messages',
                         ],
                     },
                 },
             ]
             WSGI_APPLICATION = 'realtime.wsgi.application'
             # Database
             # https://docs.djangoproject.com/en/1.11/ref/settings/#databases
             DATABASES = {
                 'default': {
                     'ENGINE': 'django.db.backends.sqlite3',
                     'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
                 }
             }
             # Password validation
             # https://docs.djangoproject.com/en/1.11/ref/settings/#auth-password-validators
             AUTH_PASSWORD_VALIDATORS = [
                 {
                     'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
                 },
                 {
                     'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
                 },
                 {
                     'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
                 },
                 {
                     'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
                 },
             ]
             # Internationalization
             # https://docs.djangoproject.com/en/1.11/topics/i18n/
             LANGUAGE_CODE = 'en-us'
             TIME_ZONE = 'UTC'
             USE_I18N = True
             USE_L10N = True
             USE_TZ = True
             # Static files (CSS, JavaScript, Images)
             # https://docs.djangoproject.com/en/1.11/howto/static-files/
             STATIC_URL = '/static/'
-            host = os.environ.get('HOST_REDIS', 'localhost')
+            host = os.environ.get('HOST_REDIS', '127.0.0.1')
             CHANNEL_LAYERS = {
                 "default": {
                     "BACKEND": "asgi_redis.RedisChannelLayer",
                     "CONFIG": {
                         "hosts": [(host, 6379)],
                     },
                     "ROUTING": "realtime.routing.channel_routing",
                 },
             }

requirements.txt 0 -1

             asgi-redis==1.4.3
             Django==1.11.7
             django-bootstrap3==9.1.0
             django-bootstrap3-datetimepicker-2==2.5.0
             channels==1.1.8
             mongoengine==0.15.0
-            numpy==1.13.3
             pymongo==3.5.1
             pyzmq==16.0.3
             redis==2.10.6
             requests==2.18.4
             simplejson==3.12.0

scripts/server.py +44 -54

@@ -1,94 +1,84
1	import os	1	import os
2	import sys	2	import sys
		3	import json
3	import simplejson	4	import simplejson
4	from datetime import datetime	5	from datetime import datetime
5	import zmq	6	import zmq
6	import redis	7	import redis
7	import asgi_redis	8	import asgi_redis
8	import mongoengine	9	import mongoengine
9		10
10	sys.path.append('/app')	11	sys.path.append('/app')
11	os.environ.setdefault("DJANGO_SETTINGS_MODULE", "realtime.settings")	12	os.environ.setdefault("DJANGO_SETTINGS_MODULE", "realtime.settings")
12		13
13	from plotter.models import Experiment, Data	14	from plotter.models import Experiment, ExpMeta, ExpData
14
15		15
16	host_mongo = os.environ.get('HOST_MONGO', 'localhost')	16	host_mongo = os.environ.get('HOST_MONGO', 'localhost')
17	mongoengine.connect('dbplots', host=host_mongo, port=27017)	17	mongoengine.connect('dbplots', host=host_mongo, port=27017)
18		18
19		19
20	host_redis = os.environ.get('HOST_REDIS', 'localhost')	20	host_redis = os.environ.get('HOST_REDIS', 'localhost')
21	channel = asgi_redis.RedisChannelLayer(hosts=[(host_redis, 6379)])	21	channel = asgi_redis.RedisChannelLayer(hosts=[(host_redis, 6379)])
22		22
23	context = zmq.Context()	23	context = zmq.Context()
24	receiver = context.socket(zmq.SUB)	24	receiver = context.socket(zmq.SUB)
25		25
26	receiver.bind("tcp://0.0.0.0:4444")	26	receiver.bind("tcp://0.0.0.0:4444")
27	receiver.setsockopt(zmq.SUBSCRIBE, '')	27	receiver.setsockopt(zmq.SUBSCRIBE, '')
28		28
		29	def loaddata():
		30	print('Loading Experiments...')
		31	for tup in json.load(open('scripts/experiments.json')):
		32	print(tup['name'])
		33	exp = Experiment.objects(code=tup['code']).modify(
		34	upsert=True,
		35	new=True,
		36	set__code=tup['code'],
		37	set__name=tup['name'],
		38	)
		39	exp.save()
29		40
30		41	def update(buffer):
31	def update_db(buffer):
32	dt = datetime.utcfromtimestamp(buffer['time'])	42	dt = datetime.utcfromtimestamp(buffer['time'])
33	exp = Expe~~rimen~~t.objects(code=buffer['exp_code'], date=dt.date()).~~first~~()	43	exp = ExpMeta.objects(code=buffer['exp_code'], date=dt.date()).modify(
34	if exp is None:	44	upsert=True,
35	exp = Experiment(	45	new=True,
36	code=buffer['exp_code'],	46	set__code=buffer['exp_code'],
37	date=dt.date(),	47	set__date=dt.date(),
38	yrange = buffer['yrange'],	48	set__yrange = buffer['yrange'],
39	xrange = buffer['xrange'],	49	set__xrange = buffer['xrange'],
40	interval = buffer['interval'],	50	set__interval = buffer['interval'],
41	localtime = buffer['localtime'],	51	set__localtime = buffer['localtime'],
42	~~name~~ = buffer['~~name~~'],	52	set__plots = buffer['data'].keys()
43	)	53	)
44	exp.save()	54	exp.save()
45		55
46	data = Data.objects(exp~~eri~~ment=exp, time=buffer['time']).~~first~~()	56	data = ExpData.objects(expmeta=exp, time=buffer['time']).modify(
		57	upsert=True,
		58	new=True,
		59	set__expmeta = exp,
		60	set__time = buffer['time'],
		61	set__data = buffer['data']
		62	)
47		63
48	if data is None:
49	data = Data(
50	experiment = exp,
51	time = buffer['time'],
52	data = buffer['data']
53	).save()
54	new = True
55	else:
56	data.data = buffer['data']
57	data.save()	64	data.save()
58	new = False
59		65
60	return ~~new~~	66	return exp.id
61	print 'Starting...'	67
		68	def main():
		69	print('Starting ZMQ server...')
62	while True:	70	while True:
63	buffer = receiver.recv_json()	71	buffer = receiver.recv_json()
64	if 'xrange' not in buffer:	72	code = update(buffer)
65	buffer['xrange'] = []	73	for plot in buffer['data']:
66	if 'name' not in buffer:
67	buffer['name'] = 'Experiment'
68	if update_db(buffer):
69	dum = buffer.copy()	74	dum = buffer.copy()
70	dum['time'] = [buffer['time']]	75	dum['time'] = [buffer['time']]
71	dum[~~'rti'~~] = buffer['data'][~~'rti'~~]	76	dum[plot] = buffer['data'][plot]
72	# dum['noise'] = buffer['data']['noise']
73	dum.pop('data')	77	dum.pop('data')
74	~~code~~ = dum.pop('exp_code')	78	dum.pop('exp_code')
75	channel.send_group(u'{}_~~rti~~'.format(code), {'text': simplejson.dumps(dum, ignore_nan=True)})	79	channel.send_group(u'{}_{}'.format(code, plot), {'text': simplejson.dumps(dum, ignore_nan=True)})
76	print 'Sending...{} - {} bytes'.format(~~'rti'~~, len(str(dum)))	80	print('Sending...{} - {} bytes'.format(plot, len(str(dum))))
77
78	# dum = buffer.copy()
79	# dum['time'] = [buffer['time']]
80	# dum['rti'] = buffer['data']['rti']
81	# dum['spc'] = buffer['data']['spc']
82	# dum['noise'] = buffer['data']['noise']
83	# dum.pop('data')
84	# code = dum.pop('exp_code')
85	# channel.send_group(u'{}_spc'.format(code), {'text': simplejson.dumps(dum, ignore_nan=True)})
86	# print 'Sending...{} - {} bytes'.format('spc', len(str(dum)))
87		81
88	# dum = buffer.copy()	82	if __name__=='__main__':
89	# dum['time'] = [buffer['time']]	83	loaddata()
90	# dum['noise'] = [[x] for x in buffer['data']['noise']]	84	main() No newline at end of file
91	# dum.pop('data')
92	# code = dum.pop('exp_code')
93	# channel.send_group(u'{}_noise'.format(code), {'text': simplejson.dumps(dum, ignore_nan=True)})
94	# print 'Sending...{} - {} bytes'.format('noise', len(str(dum)))

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages