radarsys_met Commit - r443:8c926b45a918

Update restart_reception and Add restart_pedestal

eynilupu -

r443:8c926b45a918

parent child

Context file:

r443:8c926b45a918

volumes/sirm/apps/main/management/commands/restart_pedestal.py created 644 +200 0

@@ -0,0 +1,200
	1	from django.core.management.base import BaseCommand
	2	from apps.main.models import Experiment
	3	from django.shortcuts import get_object_or_404
	4	import os, fnmatch
	5	import time
	6	from datetime import datetime
	7	import h5py
	8	import numpy as np
	9
	10	class Command(BaseCommand):
	11	"""
	12	Check pedestal acquisition each 10 minutes.
	13	Example:
	14	manage.py restart_pedestal
	15	"""
	16	def handle(self, args, *options):
	17	#start = time.time()
	18	#time.sleep(1)
	19	restart_pedestal(self)
	20	#end = time.time()
	21	#self.stdout.write(f'TIME: "{end - start}"')
	22
	23	def check_experiment():
	24	if len(Experiment.objects.filter(status=2)) > 0:
	25	return True
	26	else:
	27	return False
	28
	29	def pedestal_start(self, id_exp):
	30	all_status = Experiment.objects.filter(status=2)
	31	check_id = False
	32
	33	if len(all_status) > 0:
	34	check_id = all_status[0].pk
	35
	36	if check_id and check_id == id_exp:
	37	exp = get_object_or_404(Experiment, pk=id_exp)
	38	name = '{}-R@{}'.format(exp.name, datetime.now().strftime('%Y-%m-%dT%H-%M-%S'))
	39	exp.pedestal.start_device(name_experiment=name)
	40	self.stdout.write(f'"{exp.name}" experiment: Pedestal acquisition was restarted')
	41
	42	def pedestal_stop(self, id_exp):
	43	all_status = Experiment.objects.filter(status=2)
	44	check_id = False
	45
	46	if len(all_status) > 0:
	47	check_id = all_status[0].pk
	48
	49	if check_id and check_id == id_exp:
	50	exp = get_object_or_404(Experiment, pk=id_exp)
	51	exp.pedestal.stop_device()
	52	self.stdout.write(f'"{exp.name}" experiment: Pedestal acquisition "{exp.name}" was stopped')
	53
	54	def hdf5_list_content(get_file):
	55	table_records = np.array(get_file).tolist()
	56	table_dim = get_file.ndim
	57	table_rows = get_file.shape[0]
	58
	59	if table_dim == 1 and table_rows >= 1:
	60	#type(table_records[0]) -> float
	61	return table_records
	62	else:
	63	return False
	64
	65	def hdf5_read(file):
	66	dataspeed = {"ele_speed": False, "azi_speed": False}
	67
	68	for key, value in dataspeed.items():
	69	with h5py.File(file, 'r') as hdf:
	70	get = hdf.get('Data'+'/'+key)
	71	if get is not None:
	72	# 10 values
	73	dataspeed[key] = hdf5_list_content(get)[-10:]
	74
	75	return dataspeed
	76
	77	def count_data(last_position):
	78	pattern = "pos@*.h5"
	79	count = 0
	80	list_data = []
	81
	82	list_position = os.listdir(last_position)
	83
	84	for entry in sorted(list_position):
	85	if fnmatch.fnmatch(entry, pattern):
	86	count = count + 1
	87	list_data.append(os.path.join(last_position, entry))
	88
	89	if len(list_data) > 1:
	90	list_data = list_data[-2]
	91	else:
	92	list_data = False
	93
	94	return count, list_data
	95
	96	def response_data(datadir, old_path_datetime, old_position, new_position):
	97	path_position = True
	98	path_datetime = False
	99	read_files = False
	100
	101	rootdir = os.path.join(datadir, 'position')
	102	if os.path.isdir(rootdir):
	103	path_datetime = path_data(os.path.join(datadir, 'position'))
	104
	105	if path_datetime:
	106	if not old_path_datetime or path_datetime != old_path_datetime:
	107	old_position, read_files = count_data(path_datetime)
	108	time.sleep(65)
	109	new_position, read_files = count_data(path_datetime)
	110	else:
	111	time.sleep(65)
	112	else:
	113	path_position = False
	114
	115	return path_position, path_datetime, old_position, new_position, read_files
	116
	117	def path_data(rootdir):
	118	list_=[]
	119	for it in os.scandir(rootdir):
	120	if it.is_dir():
	121	try:
	122	datetime.strptime(it.path.split("/")[-1], "%Y-%m-%dT%H-00-00")
	123	list_.append(it.path)
	124	except ValueError:
	125	pass
	126
	127	list_ = sorted(list_, reverse=True)
	128	try:
	129	return list_[0]
	130	except:
	131	return False
	132
	133	def check_count(datadir):
	134	old_numbers = 0
	135	new_numbers = 0
	136	validation = False
	137	path_datetime = False
	138	speed = {"ele_speed": False, "azi_speed": False}
	139
	140	path_position, path_datetime, old_numbers, new_numbers, read_files = response_data(datadir, path_datetime, old_numbers, new_numbers)
	141
	142	for u in range(2):
	143	if new_numbers > old_numbers:
	144	validation = True
	145
	146	data = hdf5_read(read_files)
	147	for key, value in data.items():
	148	try:
	149	if not max(data[key]) <= 0.1:
	150	speed[key] = True
	151	except:
	152	pass
	153	break
	154	else:
	155	if u < 1:
	156	path_position, path_datetime, old_numbers, new_numbers, read_files = response_data(datadir, path_datetime, old_numbers, new_numbers)
	157
	158	return path_position, path_datetime, validation, speed
	159
	160	def restart_pedestal(self):
	161	if check_experiment():
	162
	163	all_status = Experiment.objects.filter(status=2)
	164	id_exp = all_status[0].pk
	165	datadir_exp = all_status[0].reception_rx.datadir
	166	datadir_exp = datadir_exp.replace(os.environ.get('EXPOSE_NAS', '/DATA_RM/DATA'), '/data')
	167	datadir_exp = datadir_exp.replace('/rawdata', '')
	168
	169	path_position, path_datetime, validation, speed = check_count(datadir_exp)
	170	if path_position:
	171	# Execute the process
	172	if validation:
	173	self.stdout.write(f'Acquisition pedestal is running')
	174	if speed['ele_speed'] or speed['azi_speed']:
	175	self.stdout.write(f'Pedestal speeds on Azimuth and Elevation are running')
	176	else:
	177	for key, value in speed.items():
	178	if not value:
	179	self.stdout.write(f'Speed on {key} is <= 0.1, retry')
	180
	181	pedestal_stop(self, id_exp)
	182	time.sleep(14)
	183	#pedestal_reset(self, id_exp)
	184	#time.sleep(2)
	185	pedestal_start(self, id_exp)
	186
	187	else:
	188	if not path_datetime:
	189	self.stdout.write(f'No such directory with datetime format "%Y-%m-%dT%H-00-00", retry!')
	190	else:
	191	self.stdout.write(f'No file increment, retry')
	192
	193	pedestal_stop(self, id_exp)
	194	time.sleep(14)
	195	#pedestal_reset(self, id_exp)
	196	#time.sleep(2)
	197	pedestal_start(self, id_exp)
	198
	199	else:
	200	self.stdout.write(f'No such directory: position, fail!') No newline at end of file

.env +5 -4

             #General settings
+            TZ=America/Lima
             LC_ALL=C.UTF-8
             SIRM_SITE=<SIRM SITE>
             PROC_SITE=<PROC SITE>
             CAM_SITE=<CAM SITE>
             SCHAIN_SITE=<SCHAIN SITE>
             GENERAL_PORT=<GENERAL PORT>
             BROKER_URL=<BROKER SITE>
             SOPHY_TOPIC=<SOPHY TOPIC>
             TXA_SITE=<IP TXA>
             TXB_SITE=<IP TXB>
             SIRM_MAX_UPLOAD_SIZE_MB=<SIZE MB>
             #Pedestal - az offset
             AZ_OFFSET=<AZ OFFSET>
             #Postgres settings
             POSTGRES_PORT_5432_TCP_ADDR=sirm-postgres
             POSTGRES_PORT_5432_TCP_PORT=5432
             DB_NAME=radarsys
             DB_USER=docker
             DB_PASSWORD=docker
             PGDATA=/var/lib/postgresql/data
             #Volumes - path
             EXPOSE_SIRM=./volumes/sirm
             EXPOSE_PROC=./volumes/proc
-            EXPOSE_SCHAIN=./volumes/schain
             EXPOSE_CAM=/path/to/cam
+            EXPOSE_SCHAIN=./volumes/schain
             EXPOSE_NAS=/path/to/nas_data
             EXPOSE_PGDATA=/path/to/pg_data
             EXPOSE_CERTS=/path/to/certs
             EXPOSE_DHPARAM=/path/to/dhparam
             #Superuser settings
-            SIRM_USER=admin
+            SIRM_USER=*****
-            SIRM_PASSWORD=soporte
+            SIRM_PASSWORD=*******
-            SIRM_EMAIL=admin@igp.gob.pe
  No newline at end of file
+            SIRM_EMAIL=*****@igp.gob.pe
  No newline at end of file

docker-compose.yml +7 -4

             # docker-compose up -d --build
             version: '3'
             volumes:
               sirm_web:
                 name: sirm_web
                 driver: local
                 driver_opts:
                   type: "none"
                   o: "bind"
                   device: "${EXPOSE_SIRM}"
               sirm_pgdata:
                 name: sirm_pgdata
                 driver: local
                 driver_opts:
                   type: "none"
                   o: "bind"
                   device: "${EXPOSE_PGDATA}"
               sirm_certs:
                 name: sirm_certs
                 driver: local
                 driver_opts:
                   type: "none"
                   o: "bind"
                   device: "${EXPOSE_CERTS}"
               sirm_dhparam:
                 name: sirm_dhparam
                 driver: local
                 driver_opts:
                   type: "none"
                   o: "bind"
                   device: "${EXPOSE_DHPARAM}"
               sirm_proc:
                 name: sirm_proc
                 driver: local
                 driver_opts:
                   type: "none"
                   o: "bind"
                   device: "${EXPOSE_PROC}"
               sirm_nas:
                 name: sirm_nas
                 driver: local
                 driver_opts:
                   type: "none"
                   o: "bind"
                   device: "${EXPOSE_NAS}"
               sirm_cam:
                 name: sirm_cam
                 driver: local
                 driver_opts:
                   type: "none"
                   o: "bind"
                   device: "${EXPOSE_CAM}"
               sirm_schain:
                 name: sirm_schain
                 driver: local
                 driver_opts:
                   type: "none"
                   o: "bind"
                   device: "${EXPOSE_SCHAIN}"
             services:
               sirm-nginx-proxy:
                 container_name: sirm-nginx-proxy
                 restart: always
                 build:
                   context: ./images/
                   dockerfile: nginx-proxy/Dockerfile
                   args:
                     - SIRM_MAX_UPLOAD_SIZE_MB=${SIRM_MAX_UPLOAD_SIZE_MB}
                 depends_on:
                   - sirm-web
                 networks:
                   - frontend_sirm
                   - backend_sirm
                 ports:
                   - 0.0.0.0:${GENERAL_PORT}:80
                 volumes:
                   - /var/run/docker.sock:/tmp/docker.sock:ro
                   - sirm_certs:/etc/nginx/certs:ro
                   - sirm_dhparam:/etc/nginx/dhparam
                 logging:
                   driver: "json-file"
                   options:
                     max-size: "12m"
               sirm-web:
                 container_name: 'sirm-web'
                 restart: always
                 build:
                   context: .
                 environment:
                   - LC_ALL=${LC_ALL}
                   - DB_USER=${DB_USER}
                   - DB_NAME=${DB_NAME}
                   - DB_PASSWORD=${DB_PASSWORD}
                   - POSTGRES_PORT_5432_TCP_ADDR=${POSTGRES_PORT_5432_TCP_ADDR}
                   - POSTGRES_PORT_5432_TCP_PORT=${POSTGRES_PORT_5432_TCP_PORT}
                   - EXPOSE_NAS=${EXPOSE_NAS}
                   - PROC_SITE=${PROC_SITE}
+                  - SCHAIN_SITE=${SCHAIN_SITE}
                   - SIRM_USER=${SIRM_USER}
                   - SIRM_PASSWORD=${SIRM_PASSWORD}
                   - SIRM_EMAIL=${SIRM_EMAIL}
                   - AZ_OFFSET=${AZ_OFFSET}
                   - VIRTUAL_HOST=${SIRM_SITE}
                 volumes:
                   - 'sirm_web:/workspace/sirm'
                   - 'sirm_nas:/data'
                 depends_on:
                   - sirm-postgres
                 networks:
                   - frontend_sirm
                   - backend_sirm
                 labels:
                   ofelia.enabled: "true"
-                  ofelia.job-exec.adq-exp.schedule: "@every 10s"
+                  ofelia.job-exec.restart-reception.schedule: "0 1/5 * * * *"
-                  ofelia.job-exec.adq-exp.command: "python manage.py adq_exp"
+                  ofelia.job-exec.restart-reception.command: "python manage.py restart_reception"
-                  ofelia.job-exec.restart-exp.schedule: "0 0 0/17 ? * *"
+                  ofelia.job-exec.restart-pedestal.schedule: "0 2/10 * * * *"
-                  ofelia.job-exec.restart-exp.command: "python manage.py restart_exp"
+                  ofelia.job-exec.restart-pedestal.command: "python manage.py restart_pedestal"
+                  ofelia.job-exec.restart-experiment.schedule: "0 0 5 * * *"
+                  ofelia.job-exec.restart-experiment.command: "python manage.py restart_experiment"
                 logging:
                   driver: "json-file"
                   options:
                     max-size: "12m"
               sirm-job:
                 container_name: 'sirm-job'
                 image: mcuadros/ofelia:latest
                 depends_on:
                   - sirm-web
                 networks:
                   - frontend_sirm
                   - backend_sirm
                 command: daemon --docker
                 volumes:
                   - /var/run/docker.sock:/var/run/docker.sock:ro
                 logging:
                   driver: "json-file"
                   options:
                     max-size: "12m"
               sirm-postgres:
                 container_name: 'sirm-postgres'
                 restart: always
                 build:
                   context: ./images/
                   dockerfile: postgres/Dockerfile
                   args:
                     - PGDATA=${PGDATA}
                 environment:
                   - LC_ALL=${LC_ALL}
                   - DB_USER=${DB_USER}
                   - DB_NAME=${DB_NAME}
                   - DB_PASSWORD=${DB_PASSWORD}
                   - POSTGRES_PORT_5432_TCP_ADDR=${POSTGRES_PORT_5432_TCP_ADDR}
                   - POSTGRES_PORT_5432_TCP_PORT=${POSTGRES_PORT_5432_TCP_PORT}
                 volumes:
                   - sirm_pgdata:/var/lib/postgresql/data
                 networks:
                   - backend_sirm
                 logging:
                   driver: "json-file"
                   options:
                     max-size: "12m"
               sirm-proc:
                 container_name: 'sirm-proc'
                 restart: always
                 build:
                   context: ./volumes/proc/
                 environment:
                   - BROKER_URL=${BROKER_URL}
                   - SOPHY_TOPIC=${SOPHY_TOPIC}
                   - TXA_SITE=${TXA_SITE}
                   - TXB_SITE=${TXB_SITE}
                   - SCHAIN_SITE=${SCHAIN_SITE}
                   - VIRTUAL_HOST=${PROC_SITE}
                 volumes:
                   - 'sirm_proc:/app'
                   - 'sirm_nas:/data'
                 networks:
                   - frontend_sirm
                 logging:
                   driver: "json-file"
                   options:
                     max-size: "12m"
               sirm-monitor:
                 container_name: 'sirm-monitor'
                 restart: always
                 image: 'sirm_sirm-proc'
                 command: ["python", "monitor.py"]
                 environment:
                   - BROKER_URL=${BROKER_URL}
                   - TXA_SITE=${TXA_SITE}
                   - TXB_SITE=${TXB_SITE}
                 volumes:
                   - 'sirm_proc:/app'
                   - 'sirm_nas:/data'
                 networks:
                   - frontend_sirm
                 depends_on:
                   - sirm-proc
                 logging:
                   driver: "json-file"
                   options:
                     max-size: "12m"
               sirm-acq:
                 container_name: 'sirm-acq'
                 restart: always
                 image: 'sirm_sirm-proc'
                 command: ["python", "acq.py"]
                 environment:
                   - BROKER_URL=${BROKER_URL}
                   - TXA_SITE=${TXA_SITE}
                   - TXB_SITE=${TXB_SITE}
                   - PROC_SITE=${PROC_SITE}
                 volumes:
                   - 'sirm_proc:/app'
                   - 'sirm_nas:/data'
                 networks:
                   - frontend_sirm
                 depends_on:
                   - sirm-proc
                 logging:
                   driver: "json-file"
                   options:
                     max-size: "12m"
               sirm-cam:
                 container_name: 'sirm-cam'
                 image: bkjaya1952/ivms4200-v2.8.2.2_ml-linux
                 restart: always
                 environment:
                   - VIRTUAL_HOST=${CAM_SITE}
                 volumes:
                   - 'sirm_cam:/root/.wine/drive_c/iVMS-4200'
                 networks:
                   - frontend_sirm
                 logging:
                   driver: "json-file"
                   options:
                     max-size: "12m"
               sirm-schain:
                 container_name: 'sirm-schain'
                 restart: always
                 build:
                   context: ./volumes/schain/
                 environment:
                   - BROKER_URL=${BROKER_URL}
                   - BACKEND=Agg
                   - TZ=${TZ}
                   - VIRTUAL_HOST=${SCHAIN_SITE}
                 volumes:
                   - 'sirm_nas:/data'
                   - 'sirm_schain:/app'
                 networks:
                   - frontend_sirm
                 logging:
                   driver: "json-file"
                   options:
                     max-size: "12m"
             networks:
               frontend_sirm:
                 name: frontend_sirm
               backend_sirm:
                 name: backend_sirm

requirements.txt +2 -1

             Django==4.0.3
             django-bootstrap4==22.1
             psycopg2-binary==2.9.3
             django-polymorphic==3.1.0
             gunicorn==20.1.0
             requests==2.27.1
             backports.zoneinfo==0.2.1
             asgiref==3.5.0
             sqlparse==0.4.2
             beautifulsoup4==4.10.0
             idna==3.3
             urllib3==1.26.9
             charset-normalizer==2.0.12
             certifi==2021.10.8
-            soupsieve==2.3.1
  No newline at end of file
+            soupsieve==2.3.1
+            h5py==3.7.0
  No newline at end of file

volumes/sirm/apps/main/management/commands/restart_experiment.py ~~volumes/sirm/apps/main/management/commands/restart_exp.py~~ renamed +2 -2

             from django.core.management.base import BaseCommand
             from apps.main.models import Experiment
             from django.shortcuts import get_object_or_404
             import time
             class Command(BaseCommand):
                 """
-                Restart experiment each 06 hours.
+                Restart experiment every night at 05:00 am.
                 Example:
-                    manage.py restart_exp --pk=1
+                    manage.py restart_experiment
                 """
                 def handle(self, *args, **options):
                     restart_experiment(self)
             def check_experiment():
                 if len(Experiment.objects.filter(status=2)) > 0:
                     return True
                 else:
                     return False
             def experiment_start(self, id_exp):
                 exp = get_object_or_404(Experiment, pk=id_exp)
                 if exp.status != 2 and exp.mode_stop == 'res':
                     exp.status = exp.start()
                     exp.save()
                     self.stdout.write(f'Experiment "{exp.name}" was restarted')
             def experiment_stop(self, id_exp):
                 exp = get_object_or_404(Experiment, pk=id_exp)
                 if exp.status == 2 or exp.status == 4 or exp.status == 5:
                     exp.status = exp.stop()
                     exp.mode_stop = 'res'
                     exp.save()
                     self.stdout.write(f'Experiment "{exp.name}" was stoped')
             def restart_experiment(self):
                 if check_experiment():
                     all_status = Experiment.objects.filter(status=2)
                     id_exp = all_status[0].pk
                     experiment_stop(self, id_exp)
                     time.sleep(15)
                     experiment_start(self, id_exp)

volumes/sirm/apps/main/management/commands/restart_reception.py ~~volumes/sirm/apps/main/management/commands/adq_exp.py~~ renamed +86 -41

             from django.core.management.base import BaseCommand
             from apps.main.models import Experiment
             from django.shortcuts import get_object_or_404
             import os, fnmatch
             import time
             from datetime import datetime
+            import requests
             class Command(BaseCommand):
                 """
-                Check data acquisition each 10 seconds.
+                Check data acquisition each 05 minutes.
                 Example:
-                    manage.py adq_exp
+                    manage.py restart_reception
                 """
                 def handle(self, *args, **options):
-                    restart_experiment(self)
+                    #start = time.time()
+                    time.sleep(15)
+                    restart_acquisition(self)
+                    #end = time.time()
+                    #self.stdout.write(f'TIME: "{end - start}"')
             def check_experiment():
                 if len(Experiment.objects.filter(status=2)) > 0:
                     return True
                 else:
                     return False
             def acquisition_start(self, id_exp):
                 all_status = Experiment.objects.filter(status=2)
                 check_id = False
                 if len(all_status) > 0:
                     check_id = all_status[0].pk
                 if check_id and check_id == id_exp:
                     exp = get_object_or_404(Experiment, pk=id_exp)
                     name = '{}-R@{}'.format(exp.name, datetime.now().strftime('%Y-%m-%dT%H-%M-%S'))
                     exp.reception_rx.start_device(name_experiment = name, restart = True)
                     self.stdout.write(f'"{exp.name}" experiment: Data acquisition was restarted')
+                    self.stdout.write(f'Restarting schain...')
+                    r = requests.get('http://'+os.environ.get('SCHAIN_SITE', 'sophy-schain')+'/stop')
+                    time.sleep(1)
+                    r = requests.post('http://'+os.environ.get('SCHAIN_SITE', 'sophy-schain')+'/start', json={'name': exp.name})
             def acquisition_stop(self, id_exp):
                 all_status = Experiment.objects.filter(status=2)
                 check_id = False
                 if len(all_status) > 0:
                     check_id = all_status[0].pk
                 if check_id and check_id == id_exp:
                     exp = get_object_or_404(Experiment, pk=id_exp)
                     exp.reception_rx.stop_device()
                     self.stdout.write(f'"{exp.name}" experiment: Data acquisition "{exp.name}" was stopped')
-            def count_data(datadir):
+            def count_data(last_channel):
                 pattern = "rf@*.h5"
-                rawdata = {'ch0': 0, 'ch1': 0}
+                count = 0
+                list_channel = os.listdir(last_channel)
+                for entry in sorted(list_channel):
+                    if fnmatch.fnmatch(entry, pattern):
+                        count = count + 1
+                return count
-                for key, value in rawdata.items():
+            def response_data(datadir, old_channel, old_rawdata, new_rawdata, search):
-                    last_channel = path_data(os.path.join(datadir, key))
+                path_channels = {'ch0': True, 'ch1': True}
-                    if last_channel:
+                channel = {'ch0': False, 'ch1': False}
-                        list_channel = os.listdir(last_channel)
-                        for entry in sorted(list_channel):
+                for key, value in path_channels.items():
-                            if fnmatch.fnmatch(entry, pattern):
+                    rootdir = os.path.join(datadir, key)
-                                rawdata[key] = rawdata[key] + 1
+                    if os.path.isdir(rootdir):
-                return rawdata
+                        channel[key] = path_data(os.path.join(datadir, key))
+                        if key in search:
+                            if channel[key]:
+                                if not old_channel[key] or channel[key] != old_channel[key]:
+                                    old_rawdata[key] = count_data(channel[key])
+                                time.sleep(1)
+                                new_rawdata[key] = count_data(channel[key])
+                            else:
+                                time.sleep(1)
+                    else:
+                        path_channels[key] = False
+                return path_channels, channel, old_rawdata, new_rawdata
             def path_data(rootdir):
                 list_=[]
                 for it in os.scandir(rootdir):
                     if it.is_dir():
                         try:
                             datetime.strptime(it.path.split("/")[-1], "%Y-%m-%dT%H-00-00")
                             list_.append(it.path)
                         except ValueError:
                             pass
                 list_ = sorted(list_, reverse=True)
                 try:
                     return list_[0]
                 except:
                     return False
-            def check_count(datadir, old_numbers):
+            def check_count(datadir):
-                diff = {}
+                old_numbers = {'ch0': 0, 'ch1': 0}
-                numbers = count_data(datadir)
+                new_numbers = {'ch0': 0, 'ch1': 0}
+                validation = {'ch0': False, 'ch1': False}
+                channel = {'ch0': False, 'ch1': False}
-                for key, value in numbers.items():
+                path_channels, channel, old_numbers, new_numbers = response_data(datadir, channel, old_numbers, new_numbers, ['ch0', 'ch1'])
-                    if old_numbers[key] > numbers[key]:
-                        old_numbers[key] = 0
-                    diff[key] = numbers[key] - old_numbers[key]
-                return numbers, diff
-            def restart_experiment(self):
+                for key, value in validation.items():
-                old_numbers={'ch0': 0, 'ch1': 0}
+                    for _ in range(5):
-                for count in range(5):
+                        if new_numbers[key] > old_numbers[key]:
-                    time.sleep(1)
+                            validation[key] = True
-                    if check_experiment():
+                            break
-                        all_status = Experiment.objects.filter(status=2)
-                        id_exp = all_status[0].pk
-                        datadir_exp = all_status[0].reception_rx.datadir
-                        datadir_exp = datadir_exp.replace(os.environ.get('EXPOSE_NAS', '/DATA_RM/DATA'), '/data')
-                        old_numbers, diff = check_count(datadir_exp, old_numbers)
-                        if diff['ch0'] > 0 and diff['ch1'] > 0:
-                            self.stdout.write(f'Data acquisition is running')
                         else:
-                            count = count + 1
+                            path_channels, channel, old_numbers, new_numbers = response_data(datadir, channel, old_numbers, new_numbers, [key])
-                            if count == 5:
-                                acquisition_stop(self, id_exp)
+                return path_channels, channel, validation
-                                time.sleep(1)
-                                acquisition_start(self, id_exp)
+            def restart_acquisition(self):
-                                old_numbers={'ch0': 0, 'ch1': 0}
+                if check_experiment():
+                    all_status = Experiment.objects.filter(status=2)
+                    id_exp = all_status[0].pk
+                    datadir_exp = all_status[0].reception_rx.datadir
+                    datadir_exp = datadir_exp.replace(os.environ.get('EXPOSE_NAS', '/DATA_RM/DATA'), '/data')
+                    path_channels, channel, validation = check_count(datadir_exp)
+                    if path_channels['ch0'] and path_channels['ch1']:
+                        # Execute the process
+                        if validation['ch0'] and validation['ch1']:
+                            self.stdout.write(f'Data acquisition is running')
+                        else:
+                            if not channel['ch0'] or not channel['ch1']:
+                                for key, value in channel.items():
+                                    if not value:
+                                        self.stdout.write(f'No such directory with datetime format "%Y-%m-%dT%H-00-00": channel["{key}"], retry!')
                             else:
-                                self.stdout.write(f'An error ocurred while trying to read data acquisition, Retry!')
  No newline at end of file
+                                for key, value in validation.items():
+                                    if not value:
+                                        self.stdout.write(f'No file increment: channel["{key}"]')
+                            acquisition_stop(self, id_exp)
+                            time.sleep(3)
+                            acquisition_start(self, id_exp)
+                    else:
+                        for key, value in path_channels.items():
+                            if not value:
+                                self.stdout.write(f'No such directory: channel["{key}"], fail!')
  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