radarsys_met Commit - r299:d18e81484ac8

SIR with docker-compose working

jespinoza -

r299:d18e81484ac8

parent child

Context file:

r299:d18e81484ac8

Collapse all files

.gitignore created 644 +4 0

@@ -0,0 +1,4
	1	migrations/
	2	.vscode/
	3	*.pyc
	4	.env

README.md created 644 +39 0

@@ -0,0 +1,39
	1	# Integrated Radar System (SIR)
	2
	3	The Integrated Radar System (SIR) is a web application that allows the configuration of the radar devices as required by the experiment,
	4	This app allows the creation of Campaigns, Experiment and Device Configurations.
	5	For more information visit: http://jro-dev.igp.gob.pe:3000/projects/sistema-integrado-de-radar/wiki
	6
	7	## Installation
	8
	9	We recommend use docker/docker-compose for test/production but you can install the aplication as a normal django app.
	10
	11	### 1. Download
	12
	13	Download the application radarsys to your workspace
	14
	15	$ cd /path/to/your/workspace
	16	$ git clone http://jro-dev.igp.gob.pe/rhodecode/radarsys && cd radarsys
	17
	18	### 2. Config app
	19
	20	Create enviroment vars (/path/to/radarsys/.env)
	21
	22	HOST_REDIS=radarsys-redis
	23	POSTGRES_DB_NAME=radarsys
	24	POSTGRES_PORT_5432_TCP_ADDR=radarsys-postgres
	25	POSTGRES_PORT_5432_TCP_PORT=5432
	26	POSTGRES_USER=docker
	27	POSTGRES_PASSWORD=****
	28	PGDATA=/var/lib/postgresql/data
	29	LC_ALL=C.UTF-8
	30
	31	Set database user/password in /path/to/radarsys/settings.py
	32
	33	### 3. Build application
	34
	35	$ docker-compose build
	36
	37	### 4. Run containers
	38
	39	$ docker-compose up -d No newline at end of file

postgres/Dockerfile created 644 +3 0

@@ -0,0 +1,3
	1	FROM postgres:10.1-alpine
	2
	3	RUN mkdir -p "$PGDATA" && chmod 700 "$PGDATA" No newline at end of file

postgres/docker-entrypoint-initdb.d/create_db.sh created 755 +3 0

@@ -0,0 +1,3
	1	#!/bin/env bash
	2	psql -U postgres -c "CREATE USER $POSTGRES_USER PASSWORD '$POSTGRES_PASSWORD'"
	3	psql -U postgres -c "CREATE DATABASE $POSTGRES_DB_NAME OWNER $POSTGRES_USER" No newline at end of file

.env +8 -7

@@ -1,7 +1,8
1	HOST_MYSQL=mysql	1	HOST_REDIS=radarsys-redis
2	HOST_REDIS=redis	2	POSTGRES_DB_NAME=radarsys
3	MYSQL_ROOT_PASSWORD=r00tJRO	3	POSTGRES_PORT_5432_TCP_ADDR=radarsys-postgres
4	MYSQL_DATABASE=radarsys	4	POSTGRES_PORT_5432_TCP_PORT=5432
5	MYSQL_USER=developer	5	POSTGRES_USER=docker
6	MYSQL_PASSWORD=idi2015	6	POSTGRES_PASSWORD=docker
7	HOST_REDIS=redis No newline at end of file	7	PGDATA=/var/lib/postgresql/data
		8	LC_ALL=C.UTF-8 No newline at end of file

Dockerfile +9 -2

-            FROM python:2.7.11
+            FROM python:2.7-slim
             # set working directory
             RUN mkdir /radarsys
             WORKDIR /radarsys
             # Install python dependences
             ADD requirements.txt ./requirements.txt
-            RUN pip install -v --timeout 120 -r requirements.txt --no-cache-dir
+            RUN apt-get clean && apt-get update && apt-get install -y --no-install-recommends \
+            	gcc \
+                g++ \
+                && pip install -v --timeout 120 -r requirements.txt --no-cache-dir --index-url http://10.10.20.128:8010/simple --trusted-host 10.10.20.128 \
+                && apt-get purge -y --auto-remove gcc g++\
+            	&& rm -rf /var/lib/apt/lists/*
             # Copy the main application.
             COPY . ./
+            EXPOSE 8000
             RUN python manage.py collectstatic --noinput

apps/abs/utils/Graphics_OverJro.py +1 -1

             """
             The module GRAPHICS_OVERJRO.py gathers classes or/and functions to create graphics from OVER-JRO
             project (e.g. antenna patterns, skynoise, ...).
             MODULES CALLED:
             TIME, NUMPY, MATPLOTLIB, TIMETOOLS
             MODIFICATION HISTORY:
             Created by Ing. Freddy Galindo (frederickgalindo@gmail.com). ROJ Oct 18, 2009.
             """
             import time
             import numpy
             import sys
             import os
             # set HOME environment variable to a directory the httpd server can write to
             #os.environ[ 'HOME' ] = '/usr/local/www/htdocs/overJro/tempReports'
             #os.environ[ 'HOME' ] = '/home/dsuarez/Pictures'
             #os.environ[ 'HOME' ] = '/tmp/'
             import matplotlib
             #if ide==1:
             #    matplotlib.use('Qt4Agg')
             #elif ide==2:
             #    matplotlib.use("Agg")
             #else:
             #    matplotlib.use('TKAgg')
-            #matplotlib.use("Agg")
+            matplotlib.use("Agg")
             #matplotlib.interactive(1)
             import matplotlib.pyplot
             #import Numeric
             #import scipy
             import scipy.interpolate
             import Astro_Coords
             import TimeTools
             import Graphics_Miscens
             import Misc_Routines
             class AntPatternPlot:
                 def __init__(self):
                     """
                     AntPatternPlot creates an object to call methods to plot the antenna pattern.
                     Modification History
                     --------------------
                     Created by Freddy Galindo, ROJ, 06 October 2009.
                     """
                     self.fig = matplotlib.pyplot.figure(figsize=(8,8), facecolor='white')
                     self.ax = self.fig.add_subplot(111)
                 def contPattern(self,iplot=0,gpath='',filename='',mesg='',amp=None ,x=None ,y=None ,getCut=None,title='', save=True):
                     """
                     contPattern plots a contour map of the antenna pattern.
                     Parameters
                     ----------
                     iplot = A integer to specify if the plot is  the first, second, ...  The default va-
                       lue is 0.
                     Examples
                     --------
                     >> Over_Jro.JroPattern(pattern=2).contPattern()
                     Modification history
                     --------------------
                     Converted to Python by Freddy R. Galindo, ROJ, 06 October 2009.
                     """
                     if getCut == 1:
                         return
                     xmax = numpy.max(x)
                     xmin = numpy.min(x)
                     ymax = numpy.max(y)
                     ymin = numpy.min(y)
                     levels = numpy.array([1e-3,1e-2,1e-1,0.5,1.0])
                     tmp = numpy.round(10*numpy.log10(levels),decimals=1)
                     labels = range(5)
                     for i in numpy.arange(5):labels[i] = str(numpy.int(tmp[i]))
                     colors = ((0,0,1.),(0,170/255.,0),(127/255.,1.,0),(1.,109/255.,0),(128/255.,0,0))
                     CS = self.ax.contour(x,y,amp.transpose(),levels,colors=colors)
                     fmt = {}
                     for l,s in zip(CS.levels,labels):
                         fmt[l] = s
                     self.ax.annotate('Ng',xy=(-0.05,1.04),xytext=(0.01,0.962),xycoords='axes fraction',arrowprops=dict(facecolor='black', width=1.,shrink=0.2),fontsize=15.)
                     self.ax.annotate(mesg,xy=(0,0),xytext=(0.01,0.01),xycoords='figure fraction')
                     self.ax.clabel(CS,CS.levels,inline=True,fmt=fmt,fontsize=10)
                     self.ax.set_xlim(xmin,xmax)
                     self.ax.set_ylim(ymin,ymax)
                     self.ax.set_title("Total Pattern: " + title)
                     self.ax.set_xlabel("West to South")
                     self.ax.set_ylabel("West to North")
                     self.ax.grid(True)
                     if save:
                         save_fig = os.path.join(gpath,filename)
                         self.fig.savefig(save_fig,format='png')
                 def close(self):
                     matplotlib.pyplot.close(self.fig)
                 def plotRaDec(self,gpath=None,filename=None,jd=2452640.5,ra_obs=None,xg=None,yg=None,x=None,y=None, save=True):
                     """
                     plotRaDec draws right ascension and declination lines on a JRO plane. This function
                     must call after conPattern.
                     Parameters
                     ----------
                     jd = A scalar giving the Julian date.
                     ra_obs = Scalar giving the right ascension of the observatory.
                     xg = A 3-element array to specify ..
                     yg = A 3-element array to specify ..
                     Examples
                     --------
                     >> Over_Jro.JroPattern(pattern=2).contPattern()
                     >> Over_Jro.JroPattern(pattern=2).plotRaDec(jd=jd,ra_obs=ra_obs,xg=xg,yg=yg)
                     Modification history
                     --------------------
                     Converted to Python by Freddy R. Galindo, ROJ, 06 October 2009.
                     """
                     # Finding RA of observatory for a specific date
                     if ra_obs is None:ra_obs = numpy.array([23.37060849])
                     if xg is None:xg = numpy.array([0.62918474,-0.77725579,0.])
                     if yg is None:yg = numpy.array([0.77700346,0.62898048,0.02547905])
                     # Getting HA and DEC axes
                     mindec = -28; maxdec = 4; incdec = 2.
                     ndec = numpy.int((maxdec - mindec)/incdec) + 1
                     minha = -20; maxha = 20; incha = 2.
                     nha = numpy.int((maxha - minha)/incha) + 1
                     #mcosx = numpy.zeros((nha,ndec))
                     #mcosy = numpy.zeros((nha,ndec))
                     ha_axes = numpy.reshape(numpy.arange(nha)*incha + minha,(nha,1))
                     ones_dec = numpy.reshape(numpy.zeros(ndec) + 1,(ndec,1))
                     ha_axes = numpy.dot(ha_axes,ones_dec.transpose())
                     ha_axes2 = numpy.array(ra_obs - ha_axes)
                     dec_axes = numpy.reshape(numpy.arange(ndec)*incdec + mindec,(ndec,1))
                     ones_ra = numpy.reshape(numpy.zeros(nha) + 1,(nha,1))
                     dec_axes = numpy.dot(ones_ra,dec_axes.transpose())
                     dec_axes2 = numpy.array(dec_axes)
                     ObjHor = Astro_Coords.Equatorial(ha_axes2,dec_axes2,jd)
                     [alt,az,ha] = ObjHor.change2AltAz()
                     z = numpy.transpose(alt)*Misc_Routines.CoFactors.d2r  ; z = z.flatten()
                     az = numpy.transpose(az)*Misc_Routines.CoFactors.d2r  ; az = az.flatten()
                     vect = numpy.array([numpy.cos(z)*numpy.sin(az),numpy.cos(z)*numpy.cos(az),numpy.sin(z)])
                     xg = numpy.atleast_2d(xg)
                     dcosx = numpy.array(numpy.dot(xg,vect))
                     yg = numpy.atleast_2d(yg)
                     dcosy = numpy.array(numpy.dot(yg,vect))
                     mcosx = dcosx.reshape(ndec,nha)
                     mcosy = dcosy.reshape(ndec,nha)
                     # Defining NAN for points outof limits.
                     xmax = numpy.max(x)
                     xmin = numpy.min(x)
                     ymax = numpy.max(y)
                     ymin = numpy.min(y)
                     factor = 1.3
                     noval = numpy.where((mcosx>(xmax*factor)) | (mcosx<(xmin*factor)))
                     if noval[0].size>0:mcosx[noval] = numpy.nan
                     noval = numpy.where((mcosy>(ymax*factor)) | (mcosy<(ymin*factor)))
                     if noval[0].size>0:mcosy[noval] = numpy.nan
                     # Plotting HA and declination grid.
                     iha0 = numpy.int((0 - minha)/incha)
                     idec0 = numpy.int((-14 - mindec)/incdec)
                     colorgrid = (1.,109/255.,0)
                     self.ax.plot(mcosx.transpose(),mcosy.transpose(),color=colorgrid,linestyle='--')
                     for idec in numpy.arange(ndec):
                         if idec != idec0:
                             valx = (mcosx[idec,iha0]<=xmax) & (mcosx[idec,iha0]>=xmin)
                             valy = (mcosy[idec,iha0]<=ymax) & (mcosy[idec,iha0]>=ymin)
                             if valx & valy:
                                 text = str(numpy.int(mindec + incdec*idec))+'$^o$'
                                 self.ax.text(mcosx[idec,iha0],mcosy[idec,iha0],text)
                     matplotlib.pyplot.plot(mcosx,mcosy,color=colorgrid,linestyle='--')
                     for iha in numpy.arange(nha):
                         if iha != iha0:
                             valx = (mcosx[idec0,iha]<=xmax) & (mcosx[idec0,iha]>=xmin)
                             valy = (mcosy[idec0,iha]<=ymax) & (mcosy[idec0,iha]>=ymin)
                             if valx & valy:
                                 text = str(4*numpy.int(minha + incha*iha))+"'"
                                 self.ax.text(mcosx[idec0,iha],mcosy[idec0,iha],text)
                     if save:
                         save_fig = os.path.join(gpath,filename)
                         matplotlib.pyplot.savefig(save_fig,format='png')
                 def plotBField(self,gpath,filename,dcos,alpha, nlon, nlat, dcosxrange, dcosyrange, heights, alpha_i, save=True):
                     """
                     plotBField draws the magnetic field in a directional cosines plot.
                     Parameters
                     ----------
                     dcos = An 4-dimensional array giving the directional cosines of the magnetic field
                       over the desired place.
                     alpha = An 3-dimensional array giving the angle of the magnetic field over the desi-
                       red place.
                     nlon = An integer to specify the number of elements per longitude.
                     nlat = An integer to specify the number of elements per latitude.
                     dcosxrange = A 2-element array giving the range of the  directional cosines  in the
                       "x" axis.
                     dcosyrange = A 2-element array giving the range of the  directional cosines  in the
                       "y" axis.
                     heights = An array giving the heights (km) where the magnetic field will be modeled               By default the magnetic field will be computed at 100, 500 and 1000km.
                     alpha_i = Angle to interpolate the magnetic field.
                     Modification History
                     --------------------
                     Converted to Python by Freddy R. Galindo, ROJ, 07 October 2009.
                     """
                     handles = []
                     objects = []
                     colors = ['k','m','c','b','g','r','y']
                     marker = ['-+','-*','-D','-x','-s','->','-o','-^']
                     alpha_location = numpy.zeros((nlon,2,heights.size))
                     for ih in numpy.arange(heights.size):
                         alpha_location[:,0,ih] = dcos[:,0,ih,0]
                         for ilon in numpy.arange(nlon):
                             myx = (alpha[ilon,:,ih])[::-1]
                             myy = (dcos[ilon,:,ih,0])[::-1]
                             tck = scipy.interpolate.splrep(myx,myy,s=0)
                             mydcosx = scipy.interpolate.splev(alpha_i,tck,der=0)
                             myx = (alpha[ilon,:,ih])[::-1]
                             myy = (dcos[ilon,:,ih,1])[::-1]
                             tck = scipy.interpolate.splrep(myx,myy,s=0)
                             mydcosy = scipy.interpolate.splev(alpha_i,tck,der=0)
                             alpha_location[ilon,:,ih] = numpy.array([mydcosx, mydcosy])
                         ObjFig, = self.ax.plot(alpha_location[:,0,ih],alpha_location[:,1,ih],
                             marker[ih % 8],color=colors[numpy.int(ih/8)],ms=4.5,lw=0.5)
                         handles.append(ObjFig)
                         objects.append(numpy.str(heights[ih]) + ' km')
                     self.ax.legend(handles,objects,loc="lower right", numpoints=1, handlelength=0.3,
                                    handletextpad=0.02, borderpad=0.3, labelspacing=0.1)
                     if save:
                         save_fig = os.path.join(gpath,filename)
                         matplotlib.pyplot.savefig(save_fig,format='png')
             class BFieldPlot:
                 def __init__(self):
                     """
                     BFieldPlot creates an object for drawing magnetic Field lines over Jicamarca.
                     Modification History
                     --------------------
                     Created by Freddy Galindo, ROJ, 07 October 2009.
                     """
                     self.alpha_location = 1
             #        pass
                 def plotBField(self,gpath,filename,dcos,alpha, nlon, nlat, dcosxrange, dcosyrange, heights, alpha_i):
                     """
                     plotBField draws the magnetic field in a directional cosines plot.
                     Parameters
                     ----------
                     dcos = An 4-dimensional array giving the directional cosines of the magnetic field
                       over the desired place.
                     alpha = An 3-dimensional array giving the angle of the magnetic field over the desi-
                       red place.
                     nlon = An integer to specify the number of elements per longitude.
                     nlat = An integer to specify the number of elements per latitude.
                     dcosxrange = A 2-element array giving the range of the  directional cosines  in the
                       "x" axis.
                     dcosyrange = A 2-element array giving the range of the  directional cosines  in the
                       "y" axis.
                     heights = An array giving the heights (km) where the magnetic field will be modeled               By default the magnetic field will be computed at 100, 500 and 1000km.
                     alpha_i = Angle to interpolate the magnetic field.
                     Modification History
                     --------------------
                     Converted to Python by Freddy R. Galindo, ROJ, 07 October 2009.
                     """
                     handles = []
                     objects = []
                     colors = ['k','m','c','b','g','r','y']
                     marker = ['-+','-*','-D','-x','-s','->','-o','-^']
                     alpha_location = numpy.zeros((nlon,2,heights.size))
                     for ih in numpy.arange(heights.size):
                         alpha_location[:,0,ih] = dcos[:,0,ih,0]
                         for ilon in numpy.arange(nlon):
                             myx = (alpha[ilon,:,ih])[::-1]
                             myy = (dcos[ilon,:,ih,0])[::-1]
                             tck = scipy.interpolate.splrep(myx,myy,s=0)
                             mydcosx = scipy.interpolate.splev(alpha_i,tck,der=0)
                             myx = (alpha[ilon,:,ih])[::-1]
                             myy = (dcos[ilon,:,ih,1])[::-1]
                             tck = scipy.interpolate.splrep(myx,myy,s=0)
                             mydcosy = scipy.interpolate.splev(alpha_i,tck,der=0)
                             alpha_location[ilon,:,ih] = numpy.array([mydcosx, mydcosy])
                         ObjFig, = matplotlib.pyplot.plot(alpha_location[:,0,ih],alpha_location[:,1,ih], \
                             marker[ih % 8],color=colors[numpy.int(ih/8)],ms=4.5,lw=0.5)
                         handles.append(ObjFig)
                         objects.append(numpy.str(heights[ih]) + ' km')
                     matplotlib.pyplot.xlim(dcosxrange[0],dcosxrange[1])
                     matplotlib.pyplot.ylim(dcosyrange[0],dcosyrange[1])
                     try:
                         ObjlegB = matplotlib.pyplot.legend(handles,objects,loc="lower right", numpoints=1, handlelength=0.3, \
                                             handletextpad=0.02, borderpad=0.3, labelspacing=0.1)
                     except:
                         ObjlegB = matplotlib.pyplot.legend(handles,objects,loc=[0.01,0.75], numpoints=1, handlelength=0, \
                         pad=0.015, handletextsep=0.02,labelsep=0.01)
                     matplotlib.pyplot.setp(ObjlegB.get_texts(),fontsize='small')
                     matplotlib.pyplot.gca().add_artist(ObjlegB)
                     save_fig = os.path.join(gpath,filename)
                     matplotlib.pyplot.savefig(save_fig,format='png')
                     self.alpha_location = alpha_location
             class CelestialObjectsPlot:
                 def __init__(self,jd,dec,tod,maxha_min,show_object=None):
                     self.jd = jd
                     self.dec = dec
                     self.tod = tod
                     self.maxha_min = maxha_min
                     if show_object==None:show_object=numpy.zeros(4)+2
                     self.show_object = show_object
                     self.dcosx_sun = 1
                     self.dcosy_sun = 1
                     self.ha_sun = 1
                     self.time_sun = 1
                     self.dcosx_moon = 1
                     self.dcosy_moon = 1
                     self.ha_moon = 1
                     self.time_moon = 1
                     self.dcosx_hydra = 1
                     self.dcosy_hydra = 1
                     self.ha_hydra = 1
                     self.time_hydra = 1
                     self.dcosx_galaxy = 1
                     self.dcosy_galaxy = 1
                     self.ha_galaxy = 1
                     self.time_galaxy = 1
                 def drawObject(self,glat,glon,xg,yg,dcosxrange,dcosyrange,gpath='',filename=''):
                     jd = self.jd
                     main_dec = self.dec
                     tod = self.tod
                     maxha_min = self.maxha_min
                     mesg = "Drawing celestial objects over Observatory"
             #        print mesg
             #        if textid!=None:textid.append(mesg)
                     maxlev = 24; minlev = 0; maxcol = 39; mincol = 10
                     handles = []
                     objects = ['$Sun$','$Moon$','$Hydra$','$Galaxy$']
                     marker = ['--^','--s','--*','--o']
                     # Getting RGB table to plot celestial object over Jicamarca
                     colortable = Graphics_Miscens.ColorTable(table=1).readTable()
                     for io in (numpy.arange(4)+1):
                         if self.show_object[io]!=0:
                             ObjBodies = Astro_Coords.CelestialBodies()
                             if io==1:
                                 [ra,dec,sunlon,sunobliq] = ObjBodies.sunpos(jd)
                             elif io==2:
                                 [ra,dec,dist,moonlon,moonlat] = ObjBodies.moonpos(jd)
                             elif io==3:
                                 [ra,dec] = ObjBodies.hydrapos()
                             elif io==4:
                                 [maxra,ra] = ObjBodies.skynoise_jro(dec_cut=main_dec)
                                 ra = maxra*15.
                                 dec = main_dec
                             ObjEq = Astro_Coords.Equatorial(ra,dec,jd,lat=glat,lon=glon)
                             [alt, az, ha] = ObjEq.change2AltAz()
                             vect = numpy.array([az,alt]).transpose()
                             vect = Misc_Routines.Vector(vect,direction=0).Polar2Rect()
                             dcosx = numpy.array(numpy.dot(vect,xg))
                             dcosy = numpy.array(numpy.dot(vect,yg))
                             wrap = numpy.where(ha>=180.)
                             if wrap[0].size>0:ha[wrap] = ha[wrap] - 360.
                             val = numpy.where((numpy.abs(ha))<=(maxha_min*0.25))
                             if val[0].size>2:
                                 tod_1 = tod*1.
                                 shift_1 = numpy.where(tod>12.)
                                 tod_1[shift_1] = tod_1[shift_1] - 24.
                                 tod_2 = tod*1.
                                 shift_2 = numpy.where(tod<12.)
                                 tod_2[shift_2] = tod_2[shift_2] + 24.
                                 diff0 = numpy.nanmax(tod[val])  -  numpy.nanmin(tod[val])
                                 diff1 = numpy.nanmax(tod_1[val]) - numpy.nanmin(tod_1[val])
                                 diff2 = numpy.nanmax(tod_2[val]) - numpy.nanmin(tod_2[val])
                                 if ((diff0<=diff1) & (diff0<=diff2)):
                                     tod_0 = tod
                                 elif ((diff1<diff0) & (diff1<diff2)):
                                     tod_0 = tod_1
                                 else:
                                     tod_0 = tod_2
                                 if io==1:
                                     self.dcosx_sun = dcosx[val]
                                     self.dcosy_sun = dcosy[val]
                                     self.ha_sun = ha[val]
                                     self.time_sun = numpy.median(tod_0[val])
                                 elif io==2:
                                     self.dcosx_moon = dcosx[val]
                                     self.dcosy_moon = dcosy[val]
                                     self.ha_moon = ha[val]
                                     self.time_moon = numpy.median(tod_0[val])
                                 elif io==3:
                                     self.dcosx_hydra = dcosx[val]
                                     self.dcosy_hydra = dcosy[val]
                                     self.ha_hydra = ha[val]
                                     self.time_hydra = numpy.mean(tod_0[val])
                                 elif io==4:
                                     self.dcosx_galaxy = dcosx[val]
                                     self.dcosy_galaxy = dcosy[val]
                                     self.ha_galaxy = ha[val]
                                     self.time_galaxy = numpy.mean(tod_0[val])
                                 index = numpy.mean(tod_0[val]) - minlev
                                 index = (index*(maxcol - mincol)/(maxlev - minlev)) + mincol
                                 index = numpy.int(index)
                                 figobjects, = matplotlib.pyplot.plot(dcosx[val],dcosy[val],marker[io-1],\
                                   lw=1,ms=7,mew=0,color=tuple(colortable[:,index]))
                                 handles.append(figobjects)
                     xmax = numpy.max(dcosxrange[1])
                     xmin = numpy.min(dcosxrange[0])
                     ymax = numpy.max(dcosyrange[1])
                     ymin = numpy.min(dcosyrange[0])
                     matplotlib.pyplot.xlim(xmin,xmax)
                     matplotlib.pyplot.ylim(ymin,ymax)
                     val = numpy.where(self.show_object[1:]>0)
                     objects = numpy.array(objects)
                     objects = list(objects[val])
                     try:
                         ObjlegC = matplotlib.pyplot.legend(handles,objects,loc="lower left", numpoints=1, handlelength=0.3, \
                         borderpad=0.3, handletextpad=0.02,labelspacing=0.1)
                     except:
                         ObjlegC = matplotlib.pyplot.legend(handles,objects,loc=[0.01,0.75], numpoints=1, handlelength=0, \
                         pad=0.015, handletextsep=0.02,labelsep=0.01)
                     matplotlib.pyplot.setp(ObjlegC.get_texts(),fontsize='small')
                     ObjlegC.isaxes = False
                     save_fig = os.path.join(gpath,filename)
                     matplotlib.pyplot.savefig(save_fig,format='png')
             class PatternCutPlot:
                 def __init__(self,nsubplots):
                     self.nsubplots = nsubplots
                     self.fig = None
                     self.__plot_width  = 8
                     if self.nsubplots == 5:
                         self.__plot_height = 11
                     if self.nsubplots == 4:
                         self.__plot_height = 9
                     if self.nsubplots == 3:
                         self.__plot_height = 7
                     if self.nsubplots == 2:
                         self.__plot_height = 5
                     if self.nsubplots == 1:
                         self.__plot_height = 3
                     self.fig = matplotlib.pyplot.figure(num = 4,figsize = (self.__plot_width, self.__plot_height))
                     if self.nsubplots < 5:
                         self.__height_inch = 1.1 #altura de los subplots (pulgadas)
                         top_inch = 1.5/2.7 #espacio entre el primer subplot y el limite superior del plot
                         self.__vspace_plot_inch = 1.0#1.5/2 # espacio vertical entre subplots
                         self.__left = 0.1
                     else:
                         self.__height_inch = 1.1 #altura de los subplots (pulgadas)
                         top_inch = 1.5/2.7 #espacio entre el primer subplot y el limite superior del plot
                         self.__vspace_plot_inch = 1.0 # espacio vertical entre subplots
                         self.__left = 0.1
                     self.__bottom_inch = self.__plot_height - (self.__height_inch + top_inch)
                     self.__height = self.__height_inch/self.__plot_height
                     self.__width = 0.8
                 def drawCut(self,io,patterns,npatterns,ha,otitle,subtitle,ptitle):
                     t_cuts = ['B','Sun','Moon','Hydra','Galaxy']
                     self.__bottom = self.__bottom_inch/self.__plot_height
                     subp = self.fig.add_axes([self.__left,self.__bottom,self.__width,self.__height])
                     on_axis_angle = -4.65562
                     for icut in numpy.arange(npatterns):
                         # Getting Antenna cut.
                         pattern = patterns[icut]
                         power = numpy.abs(pattern/numpy.nanmax(pattern))
                         max_power_db = numpy.round(10.*numpy.log10(numpy.nanmax(pattern)),2)
                         bval = numpy.where(power[:,0]==numpy.nanmax(power))
                         beta = -0.25*(ha[bval[0]] + on_axis_angle)
             #            print 'Angle (deg): '+"%f"%(beta)
                         subp.plot(ha,power)
                     xmax = numpy.max(numpy.nanmin(ha))
                     xmin = numpy.min(numpy.nanmax(ha))
                     ymax = numpy.max(1)
                     ymin = numpy.min(0)
                     subp.set_xlim(xmin, xmax)
                     subp.set_ylim(ymin, ymax)
                     subp.set_title(otitle + ' ' + ptitle,size="medium")
                     subp.text(0.5, 1.26,subtitle[0],
                      horizontalalignment='center',
                      verticalalignment='center',
                      transform = subp.transAxes)
                     xlabels = subp.get_xticks()
                     subp.set_xticklabels(xlabels,size="small")
                     ylabels = subp.get_yticks()
                     subp.set_yticklabels(ylabels,size="small")
                     subp.set_xlabel('Hour angle (min) (+ve to West)',size="small")
                     subp.set_ylabel("Power [Max: " + str(max_power_db) + ' dB]',size="small")
                     subp.grid()
                     self.__bottom_inch = self.__bottom_inch - (self.__height_inch + self.__vspace_plot_inch)
             class SkyNoisePlot:
                 def __init__(self,date,powr,time,time_lst):
                     """
                     SkyNoisePlot class creates an object which represents the SkyNoise Object to genera-
                     te a SkyNoise map.
                     Parameters
                     ----------
                     date = A List of 3 elements to define the desired date ([year, month, day]).
                     powr = An array giving the SkyNoise power for the desired time.
                     time = An array giving the number of seconds since 1970 to the desired time.
                     time_lst = Set this input to an array to define the Local Sidereal Time of the desi-
                       red time.
                     Modification History
                     --------------------
                     Created by Freddy Galindo, ROJ, 18 October 2009.
                     """
                     self.date = date
                     self.powr = powr
                     self.time = time
                     self.time_lst = time_lst

apps/main/templates/index.html +1 -1

             {% extends "base.html" %}
             {% load bootstrap3 %}
             {% block content-title %}Integrated Radar System{% endblock %}
             {% block content-suptitle %}at JRO{% endblock %}
             {% block content %}
-            {% lorem %}
+            <p>{% lorem %}</p>
             {% endblock %}

apps/rc/models.py +40 -20

             import ast
             import json
             import requests
             import numpy as np
             from base64 import b64encode
             from struct import pack
             from django.db import models
             from django.core.urlresolvers import reverse
             from django.core.validators import MinValueValidator, MaxValueValidator
             from apps.main.models import Configuration
             from apps.main.utils import Params
             from devices.rc import api
             from apps.rc.utils import RCFile
             LINE_TYPES = (
                 ('none', 'Not used'),
                 ('tr', 'Transmission/reception selector signal'),
                 ('tx', 'A modulating signal (Transmission pulse)'),
                 ('codes', 'BPSK modulating signal'),
                 ('windows', 'Sample window signal'),
                 ('sync', 'Synchronizing signal'),
                 ('flip', 'IPP related periodic signal'),
                 ('prog_pulses', 'Programmable pulse'),
                 ('mix', 'Mixed line'),
                 )
             SAMPLING_REFS = (
                 ('none', 'No Reference'),
                 ('begin_baud', 'Begin of the first baud'),
                 ('first_baud', 'Middle of the first baud'),
                 ('sub_baud', 'Middle of the sub-baud')
                              )
             DAT_CMDS = {
                     # Pulse Design commands
                     'DISABLE' : 0, # Disables pulse generation
                     'ENABLE' : 24, # Enables pulse generation
                     'DELAY_START' : 40, # Write delay status to memory
                     'FLIP_START' : 48, # Write flip status to memory
                     'SAMPLING_PERIOD' : 64, # Establish Sampling Period
                     'TX_ONE' : 72, # Output '0' in line TX
                     'TX_ZERO' : 88, # Output '0' in line TX
                     'SW_ONE' : 104, # Output '0' in line SW
                     'SW_ZERO' : 112, # Output '1' in line SW
                     'RESTART': 120, # Restarts CR8 Firmware
                     'CONTINUE' : 253, # Function Unknown
                     # Commands available to new controllers
                     # In Pulse Design Executable, the clock divisor code is written as 12 at the start, but it should be written as code 22(below) just before the final enable.
                     'CLOCK_DIVISOR_INIT' : 12, # Specifies Clock Divisor. Legacy command, ignored in the actual .dat conversion
                     'CLOCK_DIVISOR_LAST' : 22, # Specifies Clock Divisor (default 60 if not included) syntax: 255,22 254,N-1.
                     'CLOCK_DIVIDER' : 8,
                         }
             MAX_BITS = 8
             # Rotate left: 0b1001 --> 0b0011
             rol = lambda val, r_bits: \
                 (val << r_bits%MAX_BITS) & (2**MAX_BITS-1) | \
                 ((val & (2**MAX_BITS-1)) >> (MAX_BITS-(r_bits%MAX_BITS)))
             # Rotate right: 0b1001 --> 0b1100
             ror = lambda val, r_bits: \
                 ((val & (2**MAX_BITS-1)) >> r_bits%MAX_BITS) | \
                 (val << (MAX_BITS-(r_bits%MAX_BITS)) & (2**MAX_BITS-1))
             class RCConfiguration(Configuration):
-                ipp = models.FloatField(verbose_name='IPP [Km]', validators=[MinValueValidator(1), MaxValueValidator(9000)], default=300)
+                ipp = models.FloatField(verbose_name='IPP [Km]', validators=[MinValueValidator(1)], default=300)
-                ntx = models.PositiveIntegerField(verbose_name='Number of TX', validators=[MinValueValidator(1), MaxValueValidator(400)], default=1)
+                ntx = models.PositiveIntegerField(verbose_name='Number of TX', validators=[MinValueValidator(1)], default=1)
                 clock_in = models.FloatField(verbose_name='Clock in [MHz]', validators=[MinValueValidator(1), MaxValueValidator(80)], default=1)
                 clock_divider = models.PositiveIntegerField(verbose_name='Clock divider', validators=[MinValueValidator(1), MaxValueValidator(256)], default=1)
                 clock = models.FloatField(verbose_name='Clock Master [MHz]', blank=True, default=1)
                 time_before = models.PositiveIntegerField(verbose_name='Time before [&mu;S]', default=12)
                 time_after = models.PositiveIntegerField(verbose_name='Time after [&mu;S]', default=1)
                 sync = models.PositiveIntegerField(verbose_name='Synchro delay', default=0)
                 sampling_reference = models.CharField(verbose_name='Sampling Reference', choices=SAMPLING_REFS, default='none', max_length=40)
                 control_tx = models.BooleanField(verbose_name='Control Switch TX', default=False)
                 control_sw = models.BooleanField(verbose_name='Control Switch SW', default=False)
                 total_units = models.PositiveIntegerField(default=0)
                 mix = models.BooleanField(default=False)
                 class Meta:
                     db_table = 'rc_configurations'
                 def get_absolute_url_plot(self):
                     return reverse('url_plot_rc_pulses', args=[str(self.id)])
                 @property
                 def ipp_unit(self):
                     return '{} ({})'.format(self.ipp, int(self.ipp*self.km2unit))
                 @property
                 def us2unit(self):
                     return self.clock_in/self.clock_divider
                 @property
                 def km2unit(self):
                     return 20./3*(self.clock_in/self.clock_divider)
                 def clone(self, **kwargs):
                     lines = self.get_lines()
-                    print 'LINES'
-                    print lines
                     self.pk = None
                     self.id = None
                     for attr, value in kwargs.items():
                         setattr(self, attr, value)
                     self.save()
                     for line in lines:
                         line.clone(rc_configuration=self)
                     new_lines = self.get_lines()
                     for line in new_lines:
                         line_params = json.loads(line.params)
-                        if 'TX_ref' in line_params:
+                        if 'TX_ref' in line_params and (line_params['TX_ref'] != '0'):
                             ref_line = RCLine.objects.get(pk=line_params['TX_ref'])
                             line_params['TX_ref'] = ['{}'.format(l.pk) for l in new_lines if l.get_name()==ref_line.get_name()][0]
                             line.params = json.dumps(line_params)
                             line.save()
                     return self
                 def get_lines(self, **kwargs):
                     '''
                     Retrieve configuration lines
                     '''
                     return RCLine.objects.filter(rc_configuration=self.pk, **kwargs)
                 def clean_lines(self):
                     '''
                     '''
                     empty_line = RCLineType.objects.get(name='none')
                     for line in self.get_lines():
                         line.line_type = empty_line
                         line.params = '{}'
                         line.save()
                 def dict_to_parms(self, params, id=None):
                     '''
                     '''
                     if id:
                         data = Params(params).get_conf(id_conf=id)
                     else:
                         data = Params(params).get_conf(dtype='rc')
                     self.name = data['name']
                     self.ipp = data['ipp']
                     self.ntx = data['ntx']
                     self.clock_in = data['clock_in']
                     self.clock_divider = data['clock_divider']
                     self.clock = data['clock']
                     self.time_before = data['time_before']
                     self.time_after = data['time_after']
                     self.sync = data['sync']
                     self.sampling_reference = data['sampling_reference']
                     self.total_units = self.ipp*self.ntx*self.km2unit
                     self.save()
                     self.clean_lines()
                     positions = {'tx':0, 'tr':0}
                     for i, id in enumerate(data['lines']):
                         line_data = params['lines']['byId'][id]
                         line_type = RCLineType.objects.get(name=line_data['line_type'])
                         if line_type.name == 'codes':
                             code = RCLineCode.objects.get(name=line_data['params']['code'])
                             line_data['params']['code'] = code.pk
                         if line_type.name == 'tx':
                             position = positions['tx']
                             positions['tx'] += 1
                         elif line_type.name == 'tr':
                             position = positions['tr']
                             positions['tr'] += 1
                         else:
                             position = 0
                         line, dum = RCLine.objects.update_or_create(
                             rc_configuration=self,
                             channel=i,
                             position=position,
                             defaults={
                                 'line_type': line_type,
                                 'params': json.dumps(line_data['params'])
                                 }
                             )
                     for i, line in enumerate(self.get_lines()):
                         line_params = json.loads(line.params)
                         if 'TX_ref' in line_params:
                             if line_params['TX_ref'] in (0, '0'):
                                 line_params['TX_ref'] = '0'
                             else:
                                 ref_id = '{}'.format(line_params['TX_ref'])
                                 ref_line = params['lines']['byId'][ref_id]
                                 line_params['TX_ref'] = RCLine.objects.get(
                                     rc_configuration=self,
                                     params=json.dumps(ref_line['params'])
                                     ).pk
                             line.params = json.dumps(line_params)
                             line.save()
                 def get_delays(self):
                     pulses = [line.pulses_as_points() for line in self.get_lines()]
                     points = [tup for tups in pulses for tup in tups]
                     points = set([x for tup in points for x in tup])
                     points = list(points)
                     points.sort()
                     if points[0]!=0:
                         points.insert(0, 0)
                     return [points[i+1]-points[i] for i in range(len(points)-1)]
                 def get_pulses(self, binary=True):
                     pulses = [line.pulses_as_points() for line in self.get_lines()]
                     tuples = [tup for tups in pulses for tup in tups]
                     points = set([x for tup in tuples for x in tup])
                     points = list(points)
                     points.sort()
                     states = []
                     last = [0 for x in pulses]
                     for x in points:
                         dum = []
                         for i, tups in enumerate(pulses):
-                            ups = [tup[0] for tup in tups]
+                            ups = [tup[0] for tup in tups if tup!=(0,0)]
-                            dws = [tup[1] for tup in tups]
+                            dws = [tup[1] for tup in tups if tup!=(0,0)]
                             if x in ups:
                                 dum.append(1)
                             elif x in dws:
                                 dum.append(0)
                             else:
                                 dum.append(last[i])
                         states.append(dum)
                         last = dum
                     if binary:
                         ret = []
                         for flips in states:
                             flips.reverse()
                             ret.append(int(''.join([str(x) for x in flips]), 2))
                         states = ret
                     return states[:-1]
                 def add_cmd(self, cmd):
                     if cmd in DAT_CMDS:
                         return (255, DAT_CMDS[cmd])
                 def add_data(self, value):
                     return (254, value-1)
                 def parms_to_binary(self, dat=True):
                     '''
                     Create "dat" stream to be send to CR
                     '''
                     data = bytearray()
                     # create header
                     data.extend(self.add_cmd('DISABLE'))
                     data.extend(self.add_cmd('CONTINUE'))
                     data.extend(self.add_cmd('RESTART'))
                     if self.control_sw:
                         data.extend(self.add_cmd('SW_ONE'))
                     else:
                         data.extend(self.add_cmd('SW_ZERO'))
                     if self.control_tx:
                         data.extend(self.add_cmd('TX_ONE'))
                     else:
                         data.extend(self.add_cmd('TX_ZERO'))
                     # write divider
                     data.extend(self.add_cmd('CLOCK_DIVIDER'))
                     data.extend(self.add_data(self.clock_divider))
                     # write delays
                     data.extend(self.add_cmd('DELAY_START'))
                     # first delay is always zero
                     data.extend(self.add_data(1))
                     delays = self.get_delays()
                     for delay in delays:
                         while delay>252:
                             data.extend(self.add_data(253))
                             delay -= 253
                         data.extend(self.add_data(int(delay)))
                     # write flips
                     data.extend(self.add_cmd('FLIP_START'))
                     states = self.get_pulses(binary=True)
                     last = 0
                     for flip, delay in zip(states, delays):
                         data.extend(self.add_data((flip^last)+1))
                         last = flip
                         while delay>252:
                             data.extend(self.add_data(1))
                             delay -= 253
                     # write sampling period
                     data.extend(self.add_cmd('SAMPLING_PERIOD'))
                     wins = self.get_lines(line_type__name='windows')
                     if wins:
                         win_params = json.loads(wins[0].params)['params']
                         if win_params:
                             dh = int(win_params[0]['resolution']*self.km2unit)
                         else:
                             dh = 1
                     else:
                         dh = 1
                     data.extend(self.add_data(dh))
                     # write enable
                     data.extend(self.add_cmd('ENABLE'))
                     if not dat:
                         return data
                     return '\n'.join(['{}'.format(x) for x in data])
                 def update_pulses(self):
                     for line in self.get_lines():
                         line.update_pulses()
                 def plot_pulses2(self, km=False):
+                    import matplotlib
+                    matplotlib.use('Agg')
                     import matplotlib.pyplot as plt
                     from bokeh.resources import CDN
                     from bokeh.embed import components
                     from bokeh.mpl import to_bokeh
                     from bokeh.models.tools import WheelZoomTool, ResetTool, PanTool, HoverTool, SaveTool
                     lines = self.get_lines()
                     N = len(lines)
                     npoints = self.total_units/self.km2unit if km else self.total_units
                     fig = plt.figure(figsize=(12, 2+N*0.5))
                     ax = fig.add_subplot(111)
                     labels = ['IPP']
                     for i, line in enumerate(lines):
                         labels.append(line.get_name(channel=True))
                         l = ax.plot((0, npoints),(N-i-1, N-i-1))
                         points = [(tup[0], tup[1]-tup[0]) for tup in line.pulses_as_points(km=km) if tup!=(0,0)]
                         ax.broken_barh(points, (N-i-1, 0.5),
                                        edgecolor=l[0].get_color(), facecolor='none')
                     n = 0
                     f = ((self.ntx+50)/100)*5 if ((self.ntx+50)/100)*10>0 else 2
                     for x in np.arange(0, npoints, self.ipp if km else self.ipp*self.km2unit):
                         if n%f==0:
                             ax.text(x, N, '%s' % n, size=10)
                         n += 1
                     labels.reverse()
                     ax.set_yticks(range(len(labels)))
                     ax.set_yticklabels(labels)
                     ax.set_xlabel = 'Units'
                     plot = to_bokeh(fig, use_pandas=False)
                     plot.tools = [PanTool(dimensions=['width']), WheelZoomTool(dimensions=['width']), ResetTool(), SaveTool()]
                     plot.toolbar_location="above"
                     return components(plot, CDN)
                 def plot_pulses(self, km=False):
                     from bokeh.plotting import figure
                     from bokeh.resources import CDN
                     from bokeh.embed import components
                     from bokeh.models import FixedTicker, PrintfTickFormatter
                     from bokeh.models.tools import WheelZoomTool, ResetTool, PanTool, HoverTool, SaveTool
                     from bokeh.models.sources import ColumnDataSource
                     lines = self.get_lines().reverse()
                     N = len(lines)
                     npoints = self.total_units/self.km2unit if km else self.total_units
                     ipp = self.ipp if km else self.ipp*self.km2unit
                     hover = HoverTool(tooltips=[("Line", "@name"),
                                                 ("IPP", "@ipp"),
                                                 ("X", "@left")])
                     tools = [PanTool(dimensions=['width']),
                              WheelZoomTool(dimensions=['width']),
                              hover, SaveTool()]
                     plot = figure(width=1000,
                                   height=40+N*50,
                                   y_range = (0, N),
                                   tools=tools,
                                   toolbar_location='above',
                                   toolbar_sticky=False,)
                     plot.xaxis.axis_label = 'Km' if km else 'Units'
                     plot.xaxis[0].formatter = PrintfTickFormatter(format='%d')
                     plot.yaxis.axis_label = 'Pulses'
                     plot.yaxis[0].ticker=FixedTicker(ticks=list(range(N)))
                     plot.yaxis[0].formatter = PrintfTickFormatter(format='Line %d')
                     for i, line in enumerate(lines):
                         points = [tup for tup in line.pulses_as_points(km=km) if tup!=(0,0)]
                         source = ColumnDataSource(data = dict(
                                                               bottom = [i for tup in points],
                                                               top = [i+0.5 for tup in points],
                                                               left = [tup[0] for tup in points],
                                                               right = [tup[1] for tup in points],
                                                               ipp = [int(tup[0]/ipp) for tup in points],
                                                               name = [line.get_name() for tup in points]
                                                               ))
                         plot.quad(
                                  bottom = 'bottom',
                                  top = 'top',
                                  left = 'left',
                                  right = 'right',
                                  source = source,
                                  fill_alpha = 0,
                                  #line_color = 'blue',
                                  )
                         plot.line([0, npoints], [i, i])#, color='blue')
                     return components(plot, CDN)
                 def request(self, cmd, method='get', **kwargs):
                     req = getattr(requests, method)(self.device.url(cmd), **kwargs)
                     payload = req.json()
                     return payload
                 def status_device(self):
                     try:
                         self.device.status = 0
                         payload = self.request('status')
                         if payload['status']=='enable':
                             self.device.status = 3
                         elif payload['status']=='disable':
                             self.device.status = 2
                         else:
                             self.device.status = 1
                             self.device.save()
                             self.message = 'RC status: {}'.format(payload['status'])
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         self.device.save()
                         self.message = 'RC status: {}'.format(str(e))
                         return False
                     self.device.save()
                     return True
                 def reset_device(self):
                     try:
                         payload = self.request('reset', 'post')
                         if payload['reset']=='ok':
                             self.message = 'RC restarted OK'
                             self.device.status = 2
                             self.device.save()
                         else:
                             self.message = 'RC restart fail'
                             self.device.status = 4
                             self.device.save()
                     except Exception as e:
                         self.message = 'RC reset: {}'.format(str(e))
                         return False
                     return True
                 def stop_device(self):
                     try:
                         payload = self.request('stop', 'post')
                         self.message = 'RC stop: {}'.format(payload['stop'])
                         if payload['stop']=='ok':
                             self.device.status = 2
                             self.device.save()
                         else:
                             self.device.status = 4
                             self.device.save()
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         else:
                             self.device.status = 0
                         self.message = 'RC stop: {}'.format(str(e))
                         self.device.save()
                         return False
                     return True
                 def start_device(self):
                     try:
                         payload = self.request('start', 'post')
                         self.message = 'RC start: {}'.format(payload['start'])
                         if payload['start']=='ok':
                             self.device.status = 3
                             self.device.save()
                         else:
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         else:
                             self.device.status = 0
                         self.message = 'RC start: {}'.format(str(e))
                         self.device.save()
                         return False
                     return True
                 def write_device(self):
-                    values = zip(self.get_pulses(),
+                    #values = zip(self.get_pulses(), [x-1 for x in self.get_delays()])
-                                 [x-1 for x in self.get_delays()])
+                    values = []
+                    for pulse, delay in zip(self.get_pulses(), self.get_delays()):
+                        while delay>65535:
+                            values.append((pulse, 65535))
+                            delay -= 65535
+                        values.append((pulse, delay-1))
                     data = bytearray()
                     #reset
                     data.extend((128, 0))
                     #disable
                     data.extend((129, 0))
                     #divider
                     data.extend((131, self.clock_divider-1))
                     #enable writing
                     data.extend((139, 62))
                     last = 0
                     for tup in values:
                         vals = pack('<HH', last^tup[0], tup[1])
                         last = tup[0]
                         data.extend((133, vals[1], 132, vals[0], 133, vals[3], 132, vals[2]))
                     #enable
                     data.extend((129, 1))
                     try:
+                        payload = self.request('stop', 'post')
+                        payload = self.request('reset', 'post')
+                        #payload = self.request('divider', 'post', data={'divider': self.clock_divider-1})
+                        #payload = self.request('write', 'post', data=b64encode(bytearray((139, 62))), timeout=20)
+                        n = len(data)
+                        x = 0
+                        #while x < n:
                         payload = self.request('write', 'post', data=b64encode(data))
+                        #    x += 1024
                         if payload['write']=='ok':
                             self.device.status = 3
                             self.device.save()
                             self.message = 'RC configured and started'
                         else:
                             self.device.status = 1
                             self.device.save()
                             self.message = 'RC write: {}'.format(payload['write'])
                             return False
+                        #payload = self.request('start', 'post')
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         else:
                             self.device.status = 0
                         self.message = 'RC write: {}'.format(str(e))
                         self.device.save()
                         return False
                     return True
                 def get_absolute_url_import(self):
                     return reverse('url_import_rc_conf', args=[str(self.id)])
             class RCLineCode(models.Model):
                 name = models.CharField(max_length=40)
                 bits_per_code = models.PositiveIntegerField(default=0)
                 number_of_codes = models.PositiveIntegerField(default=0)
                 codes = models.TextField(blank=True, null=True)
                 class Meta:
                     db_table = 'rc_line_codes'
                     ordering = ('name',)
                 def __str__(self):
                     return u'%s' % self.name
             class RCLineType(models.Model):
                 name = models.CharField(choices=LINE_TYPES, max_length=40)
                 description = models.TextField(blank=True, null=True)
                 params = models.TextField(default='[]')
                 class Meta:
                     db_table = 'rc_line_types'
                 def __str__(self):
                     return u'%s - %s' % (self.name.upper(), self.get_name_display())
             class RCLine(models.Model):
                 rc_configuration = models.ForeignKey(RCConfiguration, on_delete=models.CASCADE)
                 line_type = models.ForeignKey(RCLineType)
                 channel = models.PositiveIntegerField(default=0)
                 position = models.PositiveIntegerField(default=0)
                 params = models.TextField(default='{}')
                 pulses = models.TextField(default='')
                 class Meta:
                     db_table = 'rc_lines'
                     ordering = ['channel']
                 def __str__(self):
                     if self.rc_configuration:
-                        return u'%s - %s' % (self.rc_configuration, self.get_name())
+                        return u'{}|{} - {}'.format(self.pk, self.get_name(), self.rc_configuration.name)
                 def jsonify(self):
                     data = {}
                     data['params'] = json.loads(self.params)
                     data['id'] = '{}'.format(self.pk)
                     data['line_type'] = self.line_type.name
                     data['name'] = self.get_name()
                     if data['line_type']=='codes':
                         data['params']['code'] = RCLineCode.objects.get(pk=data['params']['code']).name
                     return data
                 def clone(self, **kwargs):
                     self.pk = None
                     self.id = None
                     for attr, value in kwargs.items():
                         setattr(self, attr, value)
                     self.save()
                     return self
                 def get_name(self, channel=False):
                     chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
                     s = ''
                     if self.line_type.name in ('tx',):
                         s = chars[self.position]
                     elif self.line_type.name in ('codes', 'windows', 'tr'):
                         if 'TX_ref' in json.loads(self.params):
                             pk = json.loads(self.params)['TX_ref']
                             if pk in (0, '0'):
                                 s = ','.join(chars[l.position] for l in self.rc_configuration.get_lines(line_type__name='tx'))
                             else:
                                 ref = RCLine.objects.get(pk=pk)
                                 s = chars[ref.position]
                             s = '({})'.format(s)
                     s = '{}{}'.format(self.line_type.name.upper(), s)
                     if channel:
                         return '{} {}'.format(s, self.channel)
                     else:
                         return s
                 def get_lines(self, **kwargs):
                     return RCLine.objects.filter(rc_configuration=self.rc_configuration, **kwargs)
                 def pulses_as_array(self):
                     y = np.zeros(self.rc_configuration.total_units)
                     for tup in ast.literal_eval(self.pulses):
                         y[tup[0]:tup[1]] = 1
                     return y.astype(np.int8)
                 def pulses_as_points(self, km=False):
                     if km:
                         unit2km = 1/self.rc_configuration.km2unit
                         return [(tup[0]*unit2km, tup[1]*unit2km) for tup in ast.literal_eval(self.pulses)]
                     else:
                         return ast.literal_eval(self.pulses)
                 def get_win_ref(self, params, tx_id, km2unit):
                     ref = self.rc_configuration.sampling_reference
                     codes = [line for line in self.get_lines(line_type__name='codes') if int(json.loads(line.params)['TX_ref'])==int(tx_id)]
                     if codes:
                         tx_width = float(json.loads(RCLine.objects.get(pk=tx_id).params)['pulse_width'])*km2unit/len(json.loads(codes[0].params)['codes'][0])
                     else:
                         tx_width = float(json.loads(RCLine.objects.get(pk=tx_id).params)['pulse_width'])*km2unit
                     if ref=='first_baud':
                         return int(1 + round((tx_width + 1)/2 + params['first_height']*km2unit - params['resolution']*km2unit))
                     elif ref=='sub_baud':
                         return np.ceil(1 + params['first_height']*km2unit - params['resolution']*km2unit/2)
                     else:
                         return 0
                 def update_pulses(self):
                     '''
                     Update pulses field
                     '''
                     km2unit = self.rc_configuration.km2unit
                     us2unit = self.rc_configuration.us2unit
                     ipp = self.rc_configuration.ipp
                     ntx = int(self.rc_configuration.ntx)
                     ipp_u = int(ipp*km2unit)
                     total = ipp_u*ntx if self.rc_configuration.total_units==0 else self.rc_configuration.total_units
                     y = []
                     if self.line_type.name=='tr':
                         tr_params = json.loads(self.params)
                         if tr_params['TX_ref'] in ('0', 0):
                             txs = self.get_lines(line_type__name='tx')
                         else:
                             txs = RCLine.objects.filter(pk=tr_params['TX_ref'])
                         for tx in txs:
                             params = json.loads(tx.params)
                             if float(params['pulse_width'])==0:
                                 continue
                             delays = [float(d)*km2unit for d in params['delays'].split(',') if d]
                             width = float(params['pulse_width'])*km2unit+int(self.rc_configuration.time_before*us2unit)
                             before = 0
                             after = int(self.rc_configuration.time_after*us2unit)
                             y_tx = self.points(ntx, ipp_u, width,
                                                delay=delays,
                                                before=before,
                                                after=after,
                                                sync=self.rc_configuration.sync)
                             ranges = params['range'].split(',')
                             if len(ranges)>0 and ranges[0]!='0':
                                 y_tx = self.mask_ranges(y_tx, ranges)
                             tr_ranges = tr_params['range'].split(',')
                             if len(tr_ranges)>0 and tr_ranges[0]!='0':
                                 y_tx = self.mask_ranges(y_tx, tr_ranges)
                             y.extend(y_tx)
                         self.pulses = str(y)
                         y = self.array_to_points(self.pulses_as_array())
                     elif self.line_type.name=='tx':
                         params = json.loads(self.params)
                         delays = [float(d)*km2unit for d in params['delays'].split(',') if d]
                         width = float(params['pulse_width'])*km2unit
                         if width>0:
                             before = int(self.rc_configuration.time_before*us2unit)
                             after = 0
                             y = self.points(ntx, ipp_u, width,
                                             delay=delays,
                                             before=before,
                                             after=after,
                                             sync=self.rc_configuration.sync)
                             ranges = params['range'].split(',')
                             if len(ranges)>0 and ranges[0]!='0':
                                 y = self.mask_ranges(y, ranges)
                     elif self.line_type.name=='flip':
                         n = float(json.loads(self.params)['number_of_flips'])
                         width = n*ipp*km2unit
                         y = self.points(int((ntx+1)/(2*n)), ipp_u*n*2, width)
                     elif self.line_type.name=='codes':
                         params = json.loads(self.params)
                         tx = RCLine.objects.get(pk=params['TX_ref'])
                         tx_params = json.loads(tx.params)
                         delays = [float(d)*km2unit for d in tx_params['delays'].split(',') if d]
                         f = int(float(tx_params['pulse_width'])*km2unit/len(params['codes'][0]))
                         codes = [(np.fromstring(''.join([s*f for s in code]), dtype=np.uint8)-48).astype(np.int8) for code in params['codes']]
                         codes = [self.array_to_points(code) for code in codes]
                         n = len(codes)
                         ranges = tx_params['range'].split(',')
                         if len(ranges)>0 and ranges[0]!='0':
                             dum = self.mask_ranges(tx.pulses_as_points(), ranges)
                         else:
                             dum = tx.pulses_as_points()
                         for i, tup in enumerate(dum):
                             if tup==(0,0): continue
                             code = codes[i%n]
                             y.extend([(c[0]+tup[0], c[1]+tup[0]) for c in code])
                     elif self.line_type.name=='sync':
                         params = json.loads(self.params)
                         n = ipp_u*ntx
                         if params['invert'] in ('1', 1):
                             y = [(n-1, n)]
                         else:
                             y = [(0, 1)]
                     elif self.line_type.name=='prog_pulses':
                         params = json.loads(self.params)
                         if int(params['periodic'])==0:
                             nntx = 1
                             nipp = ipp_u*ntx
                         else:
                             nntx = ntx
                             nipp = ipp_u
                         if 'params' in params and len(params['params'])>0:
                             for p in params['params']:
                                 y_pp = self.points(nntx, nipp,
                                                    p['end']-p['begin'],
                                                    before=p['begin'])
                                 y.extend(y_pp)
                     elif self.line_type.name=='windows':
                         params = json.loads(self.params)
                         if 'params' in params and len(params['params'])>0:
-                            tr_params = json.loads(self.get_lines(line_type__name='tr')[0].params)
+                            tr_lines = self.get_lines(line_type__name='tr')
-                            tr_ranges = tr_params['range'].split(',')
+                            if tr_lines:
+                                tr_params = json.loads(self.get_lines(line_type__name='tr')[0].params)
+                                tr_ranges = tr_params['range'].split(',')
+                            else:
+                                tr_ranges = []
                             for p in params['params']:
                                 y_win = self.points(ntx, ipp_u,
                                                     p['resolution']*p['number_of_samples']*km2unit,
-                                                    before=int(self.rc_configuration.time_before*us2unit),
+                                                    before=int(self.rc_configuration.time_before*us2unit)+p['first_height']*km2unit,
                                                     sync=self.rc_configuration.sync+self.get_win_ref(p, params['TX_ref'], km2unit))
                                 if len(tr_ranges)>0 and tr_ranges[0]!='0':
                                     y_win = self.mask_ranges(y_win, tr_ranges)
                                 y.extend(y_win)
                     elif self.line_type.name=='mix':
                         values = self.rc_configuration.parameters.split('-')
                         confs = [RCConfiguration.objects.get(pk=value.split('|')[0]) for value in values]
                         modes = [value.split('|')[1] for value in values]
                         ops = [value.split('|')[2] for value in values]
                         delays = [value.split('|')[3] for value in values]
                         masks = [value.split('|')[4] for value in values]
                         mask = list('{:8b}'.format(int(masks[0])))
                         mask.reverse()
                         if mask[self.channel] in ('0', '', ' '):
                             y = np.zeros(confs[0].total_units, dtype=np.int8)
                         else:
                             y = confs[0].get_lines(channel=self.channel)[0].pulses_as_array()
                         for i in range(1, len(values)):
                             mask = list('{:8b}'.format(int(masks[i])))
                             mask.reverse()
                             if mask[self.channel] in ('0', '', ' '):
                                 continue
                             Y = confs[i].get_lines(channel=self.channel)[0].pulses_as_array()
                             delay = float(delays[i])*km2unit
                             if modes[i]=='P':
                                 if delay>0:
                                     if delay<self.rc_configuration.ipp*km2unit and len(Y)==len(y):
                                         y_temp = np.empty_like(Y)
                                         y_temp[:delay] = 0
                                         y_temp[delay:] = Y[:-delay]
                                     elif delay+len(Y)>len(y):
                                         y_new = np.zeros(delay+len(Y), dtype=np.int8)
                                         y_new[:len(y)] = y
                                         y = y_new
                                         y_temp = np.zeros(delay+len(Y), dtype=np.int8)
                                         y_temp[-len(Y):] = Y
                                     elif delay+len(Y)==len(y):
                                         y_temp = np.zeros(delay+len(Y))
                                         y_temp[-len(Y):] = Y
                                     elif delay+len(Y)<len(y):
                                         y_temp = np.zeros(len(y), dtype=np.int8)
                                         y_temp[delay:delay+len(Y)] = Y
                                 else:
                                     y_temp = Y.copy()
                                 if ops[i]=='OR':
                                     y = y | y_temp
                                 elif ops[i]=='XOR':
                                     y = y ^ y_temp
                                 elif ops[i]=='AND':
                                     y = y & y_temp
                                 elif ops[i]=='NAND':
                                     y = y & ~y_temp
                             else:
                                 y = np.concatenate([y, Y])
                         total = len(y)
                         y = self.array_to_points(y)
                     else:
                         y = []
                     if self.rc_configuration.total_units != total:
                         self.rc_configuration.total_units = total
                         self.rc_configuration.save()
                     self.pulses = str(y)
                     self.save()
                 @staticmethod
                 def array_to_points(X):
                     if X.size==0:
                         return []
                     d = X[1:]-X[:-1]
                     up = np.where(d==1)[0]
                     if X[0]==1:
                         up = np.concatenate((np.array([-1]), up))
                     up += 1
                     dw = np.where(d==-1)[0]
                     if X[-1]==1:
                         dw = np.concatenate((dw, np.array([len(X)-1])))
                     dw += 1
                     return [(tup[0], tup[1]) for tup in zip(up, dw)]
                 @staticmethod
                 def mask_ranges(Y, ranges):
                     y = [(0, 0) for __ in Y]
                     for index in ranges:
                         if '-' in index:
                             args = [int(a) for a in index.split('-')]
                             y[args[0]-1:args[1]] = Y[args[0]-1:args[1]]
                         else:
                             y[int(index)-1] = Y[int(index)-1]
                     return y
                 @staticmethod
                 def points(ntx, ipp, width, delay=[0], before=0, after=0, sync=0):
                     delays = len(delay)
                     Y = [(int(ipp*x+before+delay[x%delays]+sync), int(ipp*x+width+before+delay[x%delays]+after+sync)) for x in range(ntx)]
                     return Y

devices/rc/api.py +22 -16

             '''
             API to configure new Radar controller
             @author: Juan C. Espinoza
             '''
             import os
             import json
             import requests
             from struct import pack
             from base64 import b64encode
             class RCApi(object):
                 def __init__(self, ip, port=80):
                     self.url = 'http://{}:{}/'.format(ip, port)
                     self.params = None
                 def load(self, filename):
                     self.params = json.load(open(filename))
-                    print 'RC Configuration: {}'.format(self.params['name'])
+                    self.pk = self.params['configurations']['allIds'][0]
+                    print 'RC Configuration: {}'.format(self.params['configurations']['byId'][self.pk]['name'])
                 def status(self):
                     url = os.path.join(self.url, 'status')
                     req = requests.get(url)
                     return req.json()
                 def read(self):
                     url = os.path.join(self.url, 'read')
                     req = requests.get(url)
                     return req.json()
                 def stop(self):
                     url = os.path.join(self.url, 'stop')
                     req = requests.post(url)
                     return req.json()
                 def reset(self):
                     url = os.path.join(self.url, 'reset')
                     req = requests.post(url)
                     return req.json()
                 def start(self):
                     url = os.path.join(self.url, 'start')
                     req = requests.post(url)
                     return req.json()
                 def write(self):
                     url_write = os.path.join(self.url, 'write')
-                    url_divider = os.path.join(self.url, 'divisor')
+                    url_divider = os.path.join(self.url, 'divider')
-                    values = zip(self.params['pulses'],
+                    values = zip(self.params['configurations']['byId'][self.pk]['pulses'],
-                                 [x-1 for x in self.params['delays']])
+                                 [x-1 for x in self.params['configurations']['byId'][self.pk]['delays']])
                     payload = ''
                     for tup in values:
                         vals = pack('<HH', *tup)
-                        payload += '\x05'+vals[0]+'\x04'+vals[1]+'\x05'+vals[2]+'\x04'+vals[3]
+                        payload += '\x85'+vals[0]+'\x84'+vals[1]+'\x85'+vals[2]+'\x84'+vals[3]
                     req = requests.post(url_divider,
-                                        data={'divisor':int(self.params['clock_divider'])-1})
+                                        data={'divider':int(self.params['configurations']['byId'][self.pk]['clock_divider'])-1})
                     if 'ok' not in req.text:
                         print 'Error sending divider'
                         return False
                     req = requests.post(url_write,
                                         data=b64encode(payload))
                     return req.json()
             if __name__ == '__main__':
+                import time
                 ip = '10.10.10.100'
-                filename = '/home/jespinoza/Downloads/rc_150EEJ.json'
+                filename = './dia.json'
                 rc = RCApi(ip)
                 rc.load(filename)
-                print rc.status()
+                # print rc.status()
-                print rc.reset()
+                # time.sleep(1)
-                print rc.stop()
+                # print rc.reset()
+                # time.sleep(1)
+                # print rc.stop()
+                # time.sleep(1)
                 print rc.write()
-                print rc.start()
+                # time.sleep(1)
+                # print rc.start()

docker-compose.yml +25 -18

             version: '2'
             services:
+             # Django app
               web:
-                container_name: 'radarsys_web'
+                container_name: 'radarsys'
                 build: .
                 restart: always
                 image: radarsys
-                command: gunicorn radarsys.wsgi:application -w 2 -b :8080
+                command: gunicorn radarsys.wsgi:application -w 2 -b :8000
                 env_file: .env
-                ports:
-                  - "8080:8080"
                 links:
                   - redis
-                  - mysql
+                  - postgres
                 volumes:
-                  - './:/data'
+                  - './:/radarsys'
+                  - '/data/dockers/radarsys/static:/radarsys/static'
                 depends_on:
                   - redis
-                  - mysql
+                  - postgres
               redis:
-                container_name: 'redis'
+                container_name: 'radarsys-redis'
                 image: 'redis:3.2-alpine'
                 ports:
                   - '127.0.0.1:6300:6379'
                 volumes:
                   - '/data/dockers/radarsys/redis:/data'
               celery_worker:
+                container_name: 'radarsys-celery'
                 image: radarsys
                 env_file: .env
                 command: celery -A radarsys worker -l info
                 volumes_from:
                   - web
                 depends_on:
                   - web
-              mysql:
+              # PostgreSQL
-                container_name: 'mysql'
+              postgres:
-                image: 'mysql:5.6'
+                container_name: 'radarsys-postgres'
-                env_file: .env
+                build: ./postgres/
                 ports:
-                  - '127.0.0.1:6301:3306'
+                  - 5432:5432
                 volumes:
-                  - '/data/dockers/radarsys/mysql:/var/lib/mysql'
+                  - ./postgres/docker-entrypoint-initdb.d:/docker-entrypoint-initdb.d
+                  - pgdata:/var/lib/postgresql/data
+                env_file: .env
+              # Web Server
               nginx:
-                container_name: 'radarsys_nginx'
+                container_name: 'radarsys-nginx'
                 restart: always
                 build: ./nginx/
                 ports:
-                  - "3000:80"
+                  - '8030:8030'
-                volumes:
-                  - '/data/dockers/radarsys/nginx:/data/nginx'
                 volumes_from:
                   - web
                 links:
                   - web:web
                 depends_on:
                   - web
+            volumes:
+              pgdata:
+                driver: local
  No newline at end of file

nginx/Dockerfile +3 -5

@@ -1,5 +1,3
1	FROM tutum/nginx	1	FROM nginx:1.13.8-alpine
2		2	RUN rm /etc/nginx/conf.d/default.conf
3	RUN rm /etc/nginx/sites-enabled/default	3	ADD sites-enabled/radarsys.conf /etc/nginx/conf.d/
4	ADD sites-enabled/ /etc/nginx/sites-enabled
5	ADD sites-enabled/radarsys /etc/nginx/conf.d/

nginx/sites-enabled/radarsys.conf ~~nginx/sites-enabled/radarsys~~ renamed +4 -4

             server {
-                listen 80;
+                listen 8030;
-                server_name sir.com;
+                server_name localhost;
                 access_log /dev/stdout;
                 error_log /dev/stdout info;
                 location /static {
-                    alias /data/media/static;
+                    alias /radarsys/static;
                 }
                 location / {
-                    proxy_pass http://web:8080;
+                    proxy_pass http://web:8000;
                 }
             }

radarsys/settings.py +16 -37

             """
             Django settings for radarsys project.
             Generated by 'django-admin startproject' using Django 1.8.6.
             For more information on this file, see
             https://docs.djangoproject.com/en/1.8/topics/settings/
             For the full list of settings and their values, see
             https://docs.djangoproject.com/en/1.8/ref/settings/
             """
             # Build paths inside the project like this: os.path.join(BASE_DIR, ...)
             import os
-            BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+            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.8/howto/deployment/checklist/
             # SECURITY WARNING: keep the secret key used in production secret!
             SECRET_KEY = 'xshb$k5fc-+j16)cvyffj&9u__0q3$l!hieh#+tbzqg)*f^km0'
             # 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',
                 'polymorphic',
                 'apps.accounts',
                 'apps.main',
                 'apps.misc',
                 'apps.rc',
                 'apps.dds',
                 'apps.jars',
                 'apps.usrp',
                 'apps.abs',
                 'apps.cgs',
             )
             MIDDLEWARE_CLASSES = (
                 'django.contrib.sessions.middleware.SessionMiddleware',
                 'django.middleware.common.CommonMiddleware',
                 'django.middleware.csrf.CsrfViewMiddleware',
                 'django.contrib.auth.middleware.AuthenticationMiddleware',
                 'django.contrib.auth.middleware.SessionAuthenticationMiddleware',
                 'django.contrib.messages.middleware.MessageMiddleware',
                 'django.middleware.clickjacking.XFrameOptionsMiddleware',
                 'django.middleware.security.SecurityMiddleware',
             )
             ROOT_URLCONF = 'radarsys.urls'
             TEMPLATES = [
                 {
                     'BACKEND': 'django.template.backends.django.DjangoTemplates',
                     'DIRS': [os.path.join(BASE_DIR, "templates").replace('\\', '/'),],
                     '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 = 'radarsys.wsgi.application'
             # Database
             # https://docs.djangoproject.com/en/1.8/ref/settings/#databases
             DATABASES = {
                 'default': {
-                    #'ENGINE': 'django.db.backends.sqlite3',
+                    'ENGINE': 'django.db.backends.postgresql_psycopg2',
-                    #'NAME': os.path.join(BASE_DIR, 'radarsys.sqlite'),
+                    'NAME': os.environ.get('POSTGRES_DB_NAME', 'radarsys'),
-                    'ENGINE': 'django.db.backends.mysql',
+                    'USER': os.environ.get('POSTGRES_USER', 'docker'),
-                    'NAME': 'radarsys',
+                    'PASSWORD': os.environ.get('POSTGRES_PASSWORD', 'docker'),
-                    'USER': 'developer',
+                    'HOST': os.environ.get('POSTGRES_PORT_5432_TCP_ADDR', 'postgres'),
-                    #'HOST': 'mysql',
+                    'PORT': os.environ.get('POSTGRES_PORT_5432_TCP_PORT', ''),
-                    'PASSWORD': 'idi2015',
-                    'OPTIONS': {
-                        'init_command': "SET sql_mode='STRICT_TRANS_TABLES'",
                 }
             }
             # Internationalization
             # https://docs.djangoproject.com/en/1.8/topics/i18n/
             LANGUAGE_CODE = 'en-us'
             TIME_ZONE = None
             USE_I18N = True
             USE_L10N = True
             USE_TZ = False
             # Static files (CSS, JavaScript, Images)
             # https://docs.djangoproject.com/en/1.8/howto/static-files/
-            MEDIA_ROOT = 'media'#os.path.join(BASE_DIR, 'media')
+            MEDIA_URL = '/media/'
-            MEDIA_URL = '/site_media/'
+            MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
             STATIC_URL = '/static/'
-            #STATIC_ROOT =  '/var/www/html/static/'
+            STATIC_ROOT = os.path.join(BASE_DIR, 'static')
-            STATIC_ROOT = os.path.join(MEDIA_ROOT, 'static')
-            #STATICFILES_DIRS = (
-            #    os.path.join(BASE_DIR, 'apps', 'main', 'static'),
-            #)
             STATICFILES_FINDERS = (
                 'django.contrib.staticfiles.finders.FileSystemFinder',
                 'django.contrib.staticfiles.finders.AppDirectoriesFinder',
             )
-            FIXTURE_DIRS = (
-                os.path.join(BASE_DIR, 'apps', 'rc', 'fixtures'),
-                os.path.join(BASE_DIR, 'apps', 'main', 'fixtures'),
-                os.path.join(BASE_DIR, 'apps', 'jars', 'fixtures'),
             # Celery stuff
-            REDIS_HOST = 'redis'
+            REDIS_HOST = os.environ.get('HOST_REDIS', '127.0.0.1')
             BROKER_TRANSPORT = 'redis'
-            #--Development--# (Para Pruebas Locales)
+            BROKER_URL = 'redis://%s:6379/0' % REDIS_HOST
-            BROKER_URL = 'redis://127.0.0.1:6300'
-            CELERY_RESULT_BACKEND = 'redis://localhost:6300'
+            CELERY_RESULT_BACKEND = 'redis://%s:6379/0' % REDIS_HOST
-            #---------------#
+            CELERY_BROKER_TRANSPORT = BROKER_URL
-            #--Production---# (Para Docker)
-            #CELERY_BROKER_TRANSPORT = BROKER_URL = 'redis://%s:6379/0' % REDIS_HOST
-            #CELERY_RESULT_BACKEND = 'redis://%s:6379/0' % REDIS_HOST
-            #---------------#
             CELERY_ACCEPT_CONTENT = ['application/json']
             CELERY_TASK_SERIALIZER = 'json'
             CELERY_RESULT_SERIALIZER = 'json'
             CELERY_TIMEZONE = 'America/Lima'

readme_docker.md +8 -53

@@ -1,53 +1,8
1	### Docker de la base de datos ###	1	# Commands after dockers creations
2	# 'NAME': 'radarsys',	2
3	# 'USER': 'developer',	3	docker-compose run web python manage.py makemigrations
4	# 'PASSWORD': 'idi2015',	4	docker-compose run web python manage.py migrate
5		5	docker-compose run web python manage.py loaddata apps/main/fixtures/main_initial_data.json \
6	#Preparar Base de Datos para la aplicacion:	6	docker-compose run web python manage.py loaddata apps/rc/fixtures/rc_initial_data.json \
7	## Crear imagen "mysql:5.6"	7	docker-compose run web python manage.py loaddata apps/jars/fixtures/initial_filters_data.json \
8	docker create -v /var/lib/mysql --name mysql-radarsys-data mysql:5.6 /bin/true	8	docker-compose run web python manage.py collectstatic
9	## Ejecutar Container "mysql-radarsys-server"
10	docker run --name mysql-radarsys-server -d -e MYSQL_ROOT_PASSWORD=r00tJRO -e MYSQL_DATABASE=radarsys \
11	-e MYSQL_USER=developer -e MYSQL_PASSWORD=idi2015 --volumes-from mysql-radarsys-data mysql:5.6
12
13	#Aplicacion Sistema Integrado de Radar
14	## Debe crearse Dockerfile
15	## Crear la imagen
16	docker build -t radarsys:v01 .
17	# Ejecutar Container
18	docker run -d --name radarsys01 --link mysql-radarsys-server -p 3000:3000 \
19	-v /home/ubuntu/docker_shared/radarsys/media:/radarsys/media \
20	--add-host smtp_server:172.17.0.1 radarsys:v01
21
22	## Dentro del Container: se debe realizar las siguiente modificaciones
23	### Para ingresar al container:
24	docker exec -i -t radarsys01 /bin/bash
25	### Es necesario ejecutar:
26	apt-get update
27	apt-get install nano
28	### Modificar radarsys.setting.py, HOST debe estar habilitado
29	'HOST': 'mysql-sysinv-server',
30	### Asegurarse que:
31	MEDIA_ROOT: 'media'
32	### En el script abs/utils/Graphics_OverJro.py, matplotlib Agg debe estar habilitado
33	matplotlib.use("Agg")
34	### En el script radarsys/urls.py comentar para que nginx sirva "static":
35	#from django.contrib.staticfiles.urls import staticfiles_urlpatterns
36	#urlpatterns += staticfiles_urlpatterns()
37
38	### Ejecutar los siguientes comandos (solo si ya se creo mysql-radarsys-server):
39	python manage.py makemigrations \
40	&& python manage.py migrate \
41	&& python manage.py loaddata apps/main/fixtures/main_initial_data.json \
42	&& python manage.py loaddata apps/rc/fixtures/rc_initial_data.json \
43	&& python manage.py loaddata apps/jars/fixtures/initial_filters_data.json \
44	&& python manage.py collectstatic
45
46	### Por ultimo reiniciar el docker
47	docker stop radarsys01
48	docker start radarsys01
49
50
51	#### Archivos Compartidos:
52	# /home/ubuntu/docker_shared/radarsys/media
53	# (debe coincidir con la carpeta que se ingresar en "docker run")

requirements.txt +5 -5

             Django==1.10.1
             django-bootstrap3
-            mysqlclient
+            psycopg2
             django-polymorphic
-            bokeh
+            bokeh==0.12.1
-            numpy
+            numpy==1.13.3
             matplotlib
             scipy
             celery
             gunicorn
-            requests==2.11.1
+            requests
-            redis
+            redis
  No newline at end of file

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