##// END OF EJS Templates
jro_apps » bk_manager
RSS
***
ralonso -
r71:72
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,259 +1,259
1 1 # -*- coding: utf-8 -*-
2 2
3 3 #class BKmanager:
4 4 # def __init__(self):
5 5
6 6 from subprocess import *
7 7 import sys
8 8 import os
9 9 import subprocess
10 10 import commands
11 11 import shutil
12 12
13 13 #--------------------------------------------- Entero a cadena agregando ceros delante -------------------------------------------------
14 14
15 15 def i2s(var_n, var_length=4):
16 16 var_n2=str(var_n)
17 17 while len(var_n2) < var_length:
18 18 var_n2 = "0"+var_n2
19 19 return var_n2
20 20
21 21
22 22 #----------------------------------------- Se verifica que la ruta exista y sea un directorio -------------------------------------------------
23 23
24 24 def dir_exists(var_dir, self):
25 25 if os.path.isdir(var_dir):
26 26 return True
27 27 else:
28 28 self.txtInfo.append("Incorrect path:" + str(var_dir))
29 29 return False
30 30
31 31
32 32 #-------------------------------- Se buscan los archivos del tipo especificado y se cargan las fechas -----------------------------
33 33
34 34 def load_days(self):
35 35
36 36 self.var_list=[]
37 37 self.lstStartDay.clear()
38 38 self.lstStopDay.clear()
39 39
40 40 if self.statusDpath == False:
41 41 self.btnGbkp.setEnabled(False)
42 42 return
43 43
44 44 if self.var_Dtype == '':
45 45 return
46 46
47 47 var_cmd="find " + str(self.var_Dpath) + " -name *."+ str(self.var_Dtype) +" | awk -F/ '{print substr($NF,2,7)}' | sort| uniq"
48 48 output=commands.getstatusoutput(var_cmd)[1]
49 49
50 50 #Si no se encuentra ningun archivo
51 51 if len(output) == 0:
52 52 self.txtInfo.append("File not found")
53 53 self.btnGbkp.setEnabled(False)
54 54 return
55 55
56 56 #Se cargan las listas para seleccionar StartDay y StopDay (QComboBox)
57 57 for i in range(0, (len(output)+1)/8):
58 58 self.var_list.append(output[8*i:8*(i+1)-1])
59 59
60 60 for i in self.var_list:
61 61 self.lstStartDay.addItem(i)
62 62 self.lstStopDay.addItem(i)
63 63 self.lstStopDay.setCurrentIndex(self.lstStartDay.count()-1)
64 64
65 65 get_sub_list(self)
66 66 self.btnGbkp.setEnabled(True)
67 67
68 68
69 69 #-------------------------------------------------- Obtiene el rango de las fechas seleccionadas -----------------------------------------
70 70
71 71 def get_sub_list(self):
72 72 self.var_sublist=[]
73 73 for i in self.var_list[self.lstStartDay.currentIndex():self.lstStartDay.currentIndex() + self.lstStopDay.currentIndex()+1]:
74 74 self.var_sublist.append(i)
75 75
76 76
77 77 #----------------------------------------------------- Verifica los parametros faltantes -----------------------------------------------------------
78 78
79 79 def validate_parameters(self):
80 80 #Verifica que las ruta del proyecto sea valida
81 81 if self.statusRpath == False:
82 82 self.txtInfo.append("Incorrect proyect path")
83 83 return False
84 84
85 85 #Verifica la etiqueta
86 86 if len(self.var_Elabel) == 0:
87 87 self.txtInfo.append("Enter label")
88 88 return False
89 89
90 90 return True
91 91
92 92
93 93 #------------------------------------------------- Crea directorios en la ruta indicada -----------------------------------------------------------
94 94
95 95 def make_dirs(list_dirs, self):
96 96 """
97 97
98 98 """
99 99
100 100 for var_dir in list_dirs:
101 101 shutil.rmtree(self.var_Rpath+'/'+var_dir, True)
102 102 var_output=commands.getstatusoutput("mkdir -p "+self.var_Rpath+'/'+var_dir)[0]
103 103 if var_output != 0:
104 104 self.txtInfo.append("Error creating directory: "+var_dir+", output_error:" + str(var_output))
105 105 return False
106 106 self.txtInfo.append('Directories created correctly')
107 107 return True
108 108
109 109
110 110 #-------------------------------------------- Busca los archivos con los parametros de busqueda ---------------------------------------
111 111
112 112 def list_files(self):
113 113 var_files_list=[]
114 114 for var_doy in self.var_sublist:
115 115 var_cmd="find " + str(self.var_Dpath) + " -name ?"+var_doy+"???."+ str(self.var_Dtype) + " |sort"
116 116 var_output=commands.getstatusoutput(var_cmd)[1]
117 117 for var_file in var_output.split():
118 118 var_files_list.append(var_file) #Almacena cada archivo en la lista
119 119 return var_files_list
120 120
121 121
122 122 #--------------- Genera la lista de archivos .dat que contienen los archivos a grabar en cada DVD -----------------------
123 123
124 124 def make_files_dat(var_files_list, self):
125 125 var_Rpath_ppath=self.var_Rpath+"/ppath" #Ruta de los archivos a grabar
126 126 var_n=1 #Numero del DVD actual
127 127 var_tmp=0 #Se usa para acumular el tamaΓ±o de los archivos de la lista
128 128 var_files_list_2=[] #Se usa para almacenar la lista de archivos agrbar en cada DVD
129 129
130 130 for i in var_files_list: #Se asignan en i los archivos de la lista
131 131
132 132 var_size_i=os.path.getsize(i)/1024+1 #tamaΓ±o en KB del archivo de la lista, se suma 1 KB para evitar problemas al momento de sumar
133 133 var_tmp += var_size_i #Se acumulan el tamaΓ±o de los archivos de la lista
134 134
135 135 #Si el tamaΓ±o acumulado es mayor que el de el DVD
136 136 if var_tmp > (self.var_Dcapacity * 1024):
137 137 var_tmp -= var_size_i #se quita el tamaΓ±o sumado para mostrar el tamaΓ±o real
138 138 #se crea un archivo con numeral en el sufijo y extension .dat
139 139 var_file = open(var_Rpath_ppath+"/"+self.var_Elabel+"_"+i2s(var_n)+".dat","w")
140 140 #Se aΓ±ade la lista de archivos a grabar en el DVD al archivo .dat
141 141 for line in var_files_list_2:
142 142 var_tmp_path=line.split(self.var_Dpath)[1][:-13]
143 143 var_file.write(var_tmp_path+'='+line+'\n')
144 144 var_file.close()
145 145
146 146 var_tmp = var_size_i #Se asigna a la variable el tamaΓ±o del archivo actual
147 147 var_files_list_2=[] #Se reinicia la lista
148 148 var_n += 1
149 149 var_files_list_2.append(i)
150 150
151 151 #se crea un archivo con numeral en el sufijo y extension .dat
152 152 var_file = open(var_Rpath_ppath+"/"+self.var_Elabel+"_"+i2s(var_n)+".dat","w")
153 153 #Se aΓ±ade la lista de archivos a grabar en el DVD al archivo .dat
154 154 for line in var_files_list_2:
155 155 var_tmp_path=line.split(self.var_Dpath)[1][:-13]
156 156 var_file.write(var_tmp_path+'='+line+'\n')
157 157 var_file.close()
158 158
159 159 self.txtInfo.append("configuration files created")
160 160 return var_n
161 161
162 162
163 163 #------------------------------ Genera los archivos .print con los cuales se creara los postscript -----------------------------------
164 164
165 165 def make_files_print(self):
166 166
167 167 var_Rpath_ppath=self.var_Rpath+"/ppath" #Ruta de los archivos a grabar
168 168 var_Rpath_gpath=self.var_Rpath+"/gpath" #Ruta de los archivos postscript
169 169 var_labels=[]
170 170 for m in range (0, self.txtPSgraphic.value() - 1):
171 171 var_lines = "\n" * 9
172 172 var_labels.append(var_lines)
173 173
174 174 # Se leen todos los archivos .dat creados para crear las etiquetas en los archivos .print
175 175 for var_n in range(1, self.var_Discs + 1):
176 176
177 177 #se abren los archivos .dat en modo lectura
178 178 var_file = open(var_Rpath_ppath+"/"+self.var_Elabel+"_"+i2s(var_n)+".dat","r")
179 179 lines=var_file.readlines() # Se lee las lineas en el archivo y se almacenan en la lista
180 180 var_file.close()
181 181 list_files=[]
182 182 var_lines=[]
183 183
184 184 for j in range(0, len(lines)):
185 185
186 186 if j == 0:
187 187 var_first_folder = lines[j].split('=')[0]
188 188 var_first_file = (lines[j].split('=')[1])[:-1]
189 189 continue
190 190
191 191 var_tmp_folder = lines[j].split('=')[0]
192 192 var_tmp_file = (lines[j].split('=')[1])[:-1]
193 193
194 194 # Si el subfolder superior o el DOY del archivo actual y el anterior son diferentes
195 195 if (var_tmp_folder != var_first_folder) or (var_tmp_file[0:-5] != var_first_file[0:-5]):
196 196 var_last_file = (lines[j-1].split('=')[1])[:-1]
197 197 list_files.append([var_first_folder, var_first_file, var_last_file])
198 198
199 199 var_first_folder = lines[j].split('=')[0]
200 200 var_first_file = (lines[j].split('=')[1])[:-1]
201 201
202 202 var_last_file = (lines[-1].split('=')[1])[:-1]
203 203 list_files.append([var_first_folder, var_first_file, var_last_file])
204 204
205 205 var_lines2 = lines_print(list_files, self.var_Elabel)
206 206
207 207 for k in range(0, len(var_lines2) / 5):
208 208 var_lines=["\n"]
209 209 var_lines.append(" "+self.var_Elabel+" "+i2s(var_n)+"/"+i2s(self.var_Discs)+"\n")
210 var_lines.append("Year Doy Folder Set Time range\n")
210 var_lines.append("Year Doy Folder"+" "*6+"Set"+" "*9+"Time range\n")
211 211 var_lines.extend(var_lines2[(5*k):(5*(k+1))])
212 212 var_lines.append("\n")
213 213 var_labels.append(var_lines)
214 214
215 215 for i in range(0, (len(var_labels) // 33) +1 ):
216 216 var_file=var_Rpath_gpath+"/"+self.var_Elabel+"_"+i2s(i+1)
217 217 file_ps = open(var_file+".print","w")
218 218 if i == (len(var_labels) // 33):
219 219 var_sub_labels = var_labels[33*i:]
220 220 else:
221 221 var_sub_labels = var_labels[33*i:33*(i+1)]
222 222
223 223 for label in var_sub_labels:
224 224 for line in label:
225 225 file_ps.write(line)
226 226 file_ps.close()
227 227 var_cmd="enscript "+var_file+".print -p "+var_file+".ps -f Times-Roman7 " \
228 228 +" -3R -j -B --margins=21.25:20.4:25.51:20 --media=A4"
229 229 var_output=commands.getstatusoutput(var_cmd)[0]
230 230
231 231
232 232 def lines_print(list_files, var_Elabel):
233 233 """
234 234 Devuelve las lineas del rango de archivos de cada etiqueta segun el formato
235 235 """
236 236 var_lines=[]
237 237 for i in list_files:
238 238
239 239 # Si el archivo se grabara directamente en la / del DVD y no en un /directorio/
240 240 # se usa la etiqueta para indicar la parte de la etiqueta donde va el subdirectorio
241 241 if i[0] == '/':
242 242 var_folder = var_Elabel
243 243 else:
244 244 var_folder = i[0].split('/')[-2]
245 245
246 246 var_first_file = i[1]
247 247 var_last_file = i[2]
248 248
249 249 var_date_first_file=commands.getstatusoutput("date -r "+var_first_file+" +'%T'")[1]
250 250 var_date_last_file=commands.getstatusoutput("date -r "+var_last_file+" +'%T'")[1]
251 251
252 252 var_lines.append(var_first_file[-12:-8]+" "+var_first_file[-8:-5]+" "+var_folder +" "+var_first_file[-5:-2]+" "
253 253 +var_last_file[-5:-2]+" "+var_date_first_file+" "+var_date_last_file+"\n")
254 254 #Nos aseguramos que sea un mutiplo de 5
255 255 while (len(var_lines) % 5) != 0:
256 256 var_lines.append("\n")
257 257
258 258 return var_lines
259 259
Show file before | Show file after | Hide comments
@@ -1,159 +1,165
1 1 # -*- coding: utf-8 -*-
2 2
3 3
4 4 from subprocess import *
5 5 import sys
6 6 import os
7 7 import subprocess
8 8 import commands
9 9
10 10 #----------------------------------------------------- Deteccion de los dispositivos de grabacion ---------------------------------------------------------------
11 11
12 12 def detect_devices(self):
13 13 """
14 14 Deteccion de los dispositvos de grabacion
15 15 """
16 16 #var_cmd="wodim --devices | grep /dev/ | awk -F\' '{print $2}'" #Funciona en consola pero no en python ΒΏ?
17 17 var_cmd="wodim --devices | grep /dev/ | awk '{print $2}' | awk -F= '{print $2}'"
18
18 19 var_output = commands.getstatusoutput(var_cmd)
19 20 if var_output[0] != 0:
20 self.txtInfo.append("No se pudo encontrar los dispositivos de grabacion, output_error:" + str(var_output))
21 self.txtInfo.append("No recording devices")
21 22 else:
22 self.txtInfo.append("dispositivos encontrados")
23 # self.txtInfo.append("dispositivos encontrados")
23 24 var_devices = var_output[1].split('\n')
24 25
25 26 var_tmp=[]
26 27 for i in range(0, 4):
27 28 if i < len(var_devices):
28 29 var_len = len(var_devices[i])
29 30 var_tmp.append(var_devices[i][1:var_len - 1])
30 31 else:
31 32 var_tmp.append('')
32 33
33 34 #Se escriben los dispostivos correspodientes, si existen
34 35 self.txtDeviceA.setText(str(var_tmp[0]))
35 36 self.txtDeviceB.setText(str(var_tmp[1]))
36 37 self.txtDeviceC.setText(str(var_tmp[2]))
37 38 self.txtDeviceD.setText(str(var_tmp[3]))
38 39 #Se desactivan los que no existen
39 40 if len(var_tmp[0]) == 0 :
40 41 self.chkDevA.setChecked(False)
41 42 self.chkDevA.setEnabled(False)
42 43 if len(var_tmp[1]) == 0 :
43 44 self.chkDevB.setChecked(False)
44 45 self.chkDevB.setEnabled(False)
45 46 if len(var_tmp[2]) == 0 :
46 47 self.chkDevC.setChecked(False)
47 48 self.chkDevC.setEnabled(False)
48 49 if len(var_tmp[3]) == 0 :
49 50 self.chkDevD.setChecked(False)
50 51 self.chkDevD.setEnabled(False)
51 52
52 53 #----------------------------------- expulsa los dispositivos de grabacion --------------------------------------------
53 54
54 55 def eject_devices(self):
55 56 for var_dev in self.var_devices:
56 57 var_cmd = 'eject ' + var_dev
57 58 commands.getstatusoutput(var_cmd)
58 59
59 60 #----------------------------------- listado de los dispositivos de grabacion seleccionados --------------------------------------------
60 61
61 62 def selected_devices(self):
62 63 self.var_devices=[]
63 64 if self.chkDevA.isChecked():
64 65 self.var_devices.append(str(self.txtDeviceA.text()))
65 66 if self.chkDevB.isChecked():
66 67 self.var_devices.append(str(self.txtDeviceB.text()))
67 68 if self.chkDevC.isChecked():
68 69 self.var_devices.append(str(self.txtDeviceC.text()))
69 70 if self.chkDevD.isChecked():
70 71 self.var_devices.append(str(self.txtDeviceD.text()))
71 72
72 73 if len(self.var_devices) == 0:
73 74 return False
74 75 else:
75 76 return True
76 77
77 78
78 79 #----------------------------------------------------- Inicializacion para pruebas---------------------------------------------------------------
79 80
80 81 def set_parameters_test(self):
81 82 """
82 83 Se usa para inicializar ciertos parametros para pruebas
83 84 """
84 85 self.txtDpath.setText('/home/ricardoar/optional/STORAGE/EW_DRIFTS')
85 86 self.txtRpath.setText('/home/ricardoar/optional/prueba1_jro_backup_manager')
86 87 self.txtElabel.setText('EW_DRIFTS_pruebas')
87 88 self.lstDcapacity.setCurrentIndex(4)
88 89 self.txtDcapacity.setValue(100.0)
89 90 self.txtDcapacity.setReadOnly(False)
91 self.txtDeviceA.setText("/dev/scd0")
92 self.txtDeviceB.setText("/dev/scd1")
93 self.txtDeviceC.setText("/dev/scd2")
94 self.txtDeviceD.setText("/dev/scd3")
95
90 96
91 97
92 98 #----------------------------------------------------- crea parameters.conf ---------------------------------------------------------------
93 99
94 100 def make_parameters_conf(self):
95 101 var_file = open("parameters.conf","w")
96 102 var_file.write(self.var_Dpath+"\n") #0 Ruta de los datos
97 103 var_file.write(self.var_Rpath+"\n") #1 Ruta del proyecto
98 104 var_file.write(str(self.var_lstDtype)+"\n") #2 opcion Data Type
99 105 var_file.write(self.var_Dtype+"\n") #3 extension Data Type
100 106 var_file.write(self.var_Elabel+"\n") #4 etiqueta
101 107 var_file.write(str(self.var_Copys)+"\n") #5 Numero de copias
102 108 var_file.write(str(self.var_lstDcapacity)+"\n") #6 opcion Device Capacity
103 109 var_file.write(str(self.var_Dcapacity)+"\n") #7 tamaΓ±o Device Capacity
104 110 var_file.write(str(self.var_Discs)+"\n") #8 Numero de discos a grabar
105 111 # var_file.write(str(self.lstStartDay.currentIndex())+"\n") #9 Indice fecha inicial
106 112 # var_file.write(str(self.lstStopDay.currentIndex())+"\n") #10 Indice fecha final
107 113
108 114 var_file.close()
109 115
110 116 #----------------------------------------------------- carga parameters.conf ---------------------------------------------------------------
111 117
112 118 def get_parameters_conf(self):
113 119 var_file = open("parameters.conf","r")
114 120 lines = var_file.readlines()
115 121 self.txtDpath.setText(lines[0][:-1]) #0
116 122 self.txtRpath.setText(lines[1][:-1]) #1
117 123 self.lstDtype.setCurrentIndex(int(lines[2])) #2
118 124 self.txtDtype.setText(lines[3][:-1]) #3
119 125 self.txtElabel.setText(lines[4][:-1]) #4
120 126 self.txtCopys.setValue(int(lines[5][:-1])) #5
121 127 self.lstDcapacity.setCurrentIndex(int(lines[6])) #6
122 128 self.txtDcapacity.setValue(float(lines[7])) #7
123 129 self.var_Discs = int(lines[8]) #8
124 130 # var_StartDay = int(lines[6]) #9
125 131 # var_StopDay = int(lines[7]) #10
126 132 var_file.close()
127 133
128 134
129 135
130 136 #-------------------------- actualiza el valor de las variables con los parametros seleccionados -----------------------------
131 137
132 138 def set_vars(self):
133 139 self.var_Dpath = str(self.txtDpath.text()) #0
134 140 self.var_Rpath = str(self.txtRpath.text()) #1
135 141 self.var_lstDtype = self.lstDtype.currentIndex() #2
136 142 self.var_Dtype = str(self.txtDtype.text()) #3
137 143 self.var_Elabel = str(self.txtElabel.text()) #4
138 144 self.var_Copys = self.txtCopys.value() #5
139 145 self.var_lstDcapacity = self.lstDcapacity.currentIndex() #6
140 146 self.var_Dcapacity = self.txtDcapacity.value() #7
141 147 self.var_Discs = self.var_Discs #8
142 148
143 149 #---------------------------------------------- Habilitacion y deshabilitacion de items -------------------------------------------------------
144 150
145 151 def enabled_items1(var_bool, self):
146 152 self.tabParameters.setEnabled(not(var_bool))
147 153 self.lstDcapacity.setEnabled(not(var_bool))
148 154 self.txtDcapacity.setEnabled(not(var_bool))
149 155 self.actionChange_Parameters.setEnabled(var_bool)
150 156 self.btnGbkp.setEnabled(not(var_bool))
151 157 self.btnRestart.setEnabled(var_bool)
152 158 self.btnStartburn.setEnabled(var_bool)
153 159
154 160
155 161 def enabled_items2(var_bool, self):
156 162 self.btnRestart.setEnabled(not(var_bool))
157 163 self.btnStartburn.setEnabled(not(var_bool))
158 164 self.btnStopburn.setEnabled(var_bool)
159 165 self.chkCheck.setEnabled(not(var_bool))
Show file before | Show file after | Hide comments
@@ -1,467 +1,484
1 1 # -*- coding: utf-8 -*-
2 2
3 3 """
4 4 Module implementing MainWindow.
5 5 """
6 6
7 7 from PyQt4.QtGui import QMainWindow
8 8 from PyQt4.QtCore import pyqtSignature
9 9 from PyQt4 import QtCore
10 10 from Ui_MainWindow import Ui_MainWindow
11 11 from Ui_Parameters import Ui_Parameters
12 12 from Ui_About import Ui_About
13 13 from PyQt4 import QtGui
14 14 from subprocess import *
15 15 import sys
16 16 import os
17 17 #import subprocess
18 18 import commands
19 19 from functions import functions
20 20 from functions import functions2
21 21
22 22 class MainWindow(QMainWindow, Ui_MainWindow):
23 23 """
24 24 Class documentation goes here.
25 25 """
26 26
27 27 def __init__(self, parent = None):
28 28 QMainWindow.__init__(self, parent)
29 29 self.setupUi(self)
30 30
31 31 self.setupUi2()
32 32 #sys.stdout = self #redirige salida estandar
33 33
34 34 def setupUi2(self):
35 35
36 36 # functions2.detect_devices(self) #busca los dispositivos de grabacion
37 37
38 38 self.var_Discs = 0 #Numero de discos del proyecto
39 39 self.var_Copys = 0 #Numero de copias
40 40 self.var_disc_n = 0
41 41 self.var_copy_n = 0
42 42
43 43 self.var_list=[]
44 44 self.var_sublist=[]
45 45
46 46 self.var_devices=[]
47 47
48 48 self.var_step = 0
49 49 self.bool_state_burning = False
50 50 self.blank_discs = False
51 51
52 52
53 53 #Revisa si existe el archivo de confirguracion
54 54 if os.path.isfile("parameters.conf"):
55 55 self.txtInfo.append("Parameters were loaded from configuration file")
56 56 functions2.get_parameters_conf(self)
57 self.txtInfo.append("El proyecto es de "+str(self.var_Discs)+" discos")
57 self.txtInfo.append("Total number of discs for recording: "+str(self.var_Discs * self.var_Copys))
58
58 59 else:
59 self.txtInfo.append("Elija los parametros de configuracion")
60 # self.txtInfo.append("Elija los parametros de configuracion")
60 61 functions2.set_parameters_test(self) #Establece ciertos parametros, para pruebas
61 62
62 63 functions2.set_vars(self) #Carga las variables de la clase con los parametros seleccionados
63 64
64 65 self.statusDpath = functions.dir_exists(self.var_Dpath, self)
65 66 self.statusRpath = functions.dir_exists(self.var_Rpath, self)
66 67 functions.load_days(self)
67 68
68 69 if os.path.isfile("parameters.conf"):
69 70 functions2.enabled_items1(True, self) #Se bloquean los parametros de configuracion
70 71
71 72 self.connect(self.actionChange_Parameters, QtCore.SIGNAL("triggered()"), self.changeParameters)
72 73 self.connect(self.actionAbout, QtCore.SIGNAL("triggered()"), self.about)
73 74
74 75 self.var_process = QtCore.QProcess()
75 76 self.connect(self.var_process, QtCore.SIGNAL('readyReadStandardOutput()'), self.readOuput)
76 77 self.connect(self.var_process, QtCore.SIGNAL('readyReadStandardError()'), self.readError)
77 78 self.connect(self.var_process, QtCore.SIGNAL('finished(int,QProcess::ExitStatus)'), self.finished)
78 79
80 self.var_process_check = QtCore.QProcess()
81 self.connect(self.var_process_check, QtCore.SIGNAL('readyReadStandardOutput()'), self.readOuput_check)
82 self.connect(self.var_process_check, QtCore.SIGNAL('readyReadStandardError()'), self.readError_check)
83 self.connect(self.var_process_check, QtCore.SIGNAL('finished(int,QProcess::ExitStatus)'), self.finished_check)
79 84
80 85 def write(self, txt):
81 86 self.txtInfo.append(str(txt))
82 87
83 88 def changeParameters(self):
84 89 dlg=QtGui.QDialog()
85 90 dlgui=Ui_Parameters()
86 91 dlgui.setupUi(dlg)
87 92 if (dlg.exec_() == QtGui.QDialog.Accepted):
88 93 if dlgui.txtDisc.value() > self.var_Discs or dlgui.txtCopy.value() > dlgui.txtNcopys.value():
89 94 self.txtInfo.append("Wrong parameters")
90 95 else:
91 96 self.var_Copys = dlgui.txtNcopys.value()
92 97 self.var_disc_n = dlgui.txtDisc.value()
93 98 self.var_copy_n = dlgui.txtCopy.value()
94 99 self.txtInfo.append("Changed parameters")
95 100
96 101
97 102 def about(self):
98 103 dlg_about=QtGui.QDialog()
99 104 dlgui_about=Ui_About()
100 105 dlgui_about.setupUi(dlg_about)
101 106 dlg_about.exec_()
102 107
103 108 #----------------------------------------------------- Funciones del proceso ---------------------------------------------------------------
104 109
105 110 def readOuput(self):
106 111 self.txtInfo.insertPlainText("stdout: " + QtCore.QString(self.var_process.readAllStandardOutput()))
107 112
108 113 def readError(self):
109 114 self.txtInfo.setText("stderr: " + QtCore.QString(self.var_process.readAllStandardError()))
110 115
111 116 def finished(self):
112 117 self.txtInfo.append("proceso terminado finished() "+QtCore.QString(self.var_process.exitCode())+"\n")
113 118 if self.var_disc_n <= self.var_Discs and self.bool_state_burning:
114 119 self.burning()
115 120
116 121
122 #----------------------------------------------------- Funciones del proceso de verificacion ---------------------------------------------------------------
123
124 def readOuput_check(self):
125 self.txtInfo.insertPlainText("stdout check: " + QtCore.QString(self.var_process_check.readAllStandardOutput()))
126
127 def readError_check(self):
128 self.txtInfo.setText("stderr check: " + QtCore.QString(self.var_process_check.readAllStandardError()))
129
130 def finished_check(self):
131 self.txtInfo.append("proceso terminado finished() check"+QtCore.QString(self.var_process_check.exitCode())+"\n")
132
133
117 134 #----------------------------------------------------- Obtencion de la ruta de los datos ---------------------------------------------------------------
118 135
119 136 @pyqtSignature("")
120 137 def on_btnDpath_clicked(self):
121 138 """
122 139 Permite seleccionar graficamente el direcorio de los datos a grabar
123 140 """
124 141 self.var_Dpath= str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
125 142 self.txtDpath.setText(self.var_Dpath)
126 143 self.statusDpath = functions.dir_exists(self.var_Dpath, self)
127 144 functions.load_days(self)
128 145
129 146
130 147 @pyqtSignature("")
131 148 def on_txtDpath_editingFinished(self):
132 149 """
133 150 Carga la ruta editada y verifica que sea correcta y carga la lista de dias
134 151 """
135 152 self.var_Dpath=str(self.txtDpath.text()) #Se carga la variable con la ruta recien editada
136 153 self.statusDpath = functions.dir_exists(self.var_Dpath, self)
137 154 functions.load_days(self)
138 155
139 156
140 157 #----------------------------------------------------- Obtencion de las ruta del proyecto ---------------------------------------------------------------
141 158
142 159 @pyqtSignature("")
143 160 def on_btnRpath_clicked(self):
144 161 """
145 162 Permite seleccionar graficamente el direcorio del proyecto
146 163 """
147 164 self.var_Rpath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
148 165 self.txtRpath.setText(self.var_Rpath)
149 166 self.statusRpath = functions.dir_exists(self.var_Rpath, self)
150 167
151 168
152 169 @pyqtSignature("")
153 170 def on_txtRpath_editingFinished(self):
154 171 """
155 172 Valida la ruta del proyecto
156 173 """
157 174 self.var_Rpath = str(self.txtRpath.text()) #Se carga la variable con la ruta recien editada
158 175 self.statusRpath = functions.dir_exists(self.var_Rpath, self)
159 176
160 177
161 178 #----------------------------------------------------- Tipo de datos ---------------------------------------------------------------
162 179
163 180 @pyqtSignature("int")
164 181 def on_lstDtype_activated(self, index):
165 182 """
166 183 Permite elegir entre los tipos de archivos
167 184 """
168 185 self.txtDtype.setReadOnly(True)
169 186 if index == 0:
170 187 self.var_Dtype ='r'
171 188 elif index == 1:
172 189 self.var_Dtype ='pdata'
173 190 elif index == 2:
174 191 self.var_Dtype ='sswma'
175 192 else :
176 193 self.var_Dtype =''
177 194 self.txtDtype.setReadOnly(False)
178 195
179 196 self.txtDtype.setText(self.var_Dtype)
180 197 functions.load_days(self) #llamada a funcion
181 198
182 199 @pyqtSignature("")
183 200 def on_txtDtype_editingFinished(self):
184 201 self.var_Dtype=str(self.txtDtype.text())
185 202 functions.load_days(self) #llamada a funcion
186 203
187 204
188 205 #----------------------------------------------------- Etiqueta ---------------------------------------------------------------
189 206
190 207 @pyqtSignature("")
191 208 def on_txtElabel_editingFinished(self):
192 209 self.var_Elabel = str(self.txtElabel.text())
193 210
194 211 #----------------------------------------------------- Numero de copias ---------------------------------------------------------------
195 212 @pyqtSignature("")
196 213 def on_txtCopys_editingFinished(self):
197 214 self.var_Copys = self.txtCopys.value()
198 215
199 216 #----------------------------------------------------- Seleccion del rango de fechas ---------------------------------------------------------------
200 217
201 218 @pyqtSignature("int") #CLOSED
202 219 def on_lstStartDay_activated(self, index):
203 220 """
204 221 Cambia la lista de opciones en lstStopDay
205 222 """
206 223 var_StopDay_index=self.lstStopDay.count() - self.lstStopDay.currentIndex()
207 224 self.lstStopDay.clear()
208 225
209 226 for i in self.var_list[index:]:
210 227 self.lstStopDay.addItem(i)
211 228
212 229 self.lstStopDay.setCurrentIndex(self.lstStopDay.count() - var_StopDay_index)
213 230
214 231 functions.get_sub_list(self)
215 232
216 233
217 234 @pyqtSignature("int") #CLOSED
218 235 def on_lstStopDay_activated(self, index):
219 236 """
220 237 Cambia la lista de opciones en lstStartDay
221 238 """
222 239 var_StartDay_index=self.lstStartDay.currentIndex()
223 240 var_end_index = self.lstStopDay.count() - index
224 241 self.lstStartDay.clear()
225 242
226 243 for i in self.var_list[:len(self.var_list) - var_end_index + 1]:
227 244 self.lstStartDay.addItem(i)
228 245
229 246 self.lstStartDay.setCurrentIndex(var_StartDay_index)
230 247
231 248 functions.get_sub_list(self)
232 249
233 250
234 251 #----------------------------------------------------- Capacidad del dispositivo de grabacion ---------------------------------------------------------------
235 252
236 253 @pyqtSignature("")
237 254 def on_txtDcapacity_editingFinished(self):
238 255 self.var_Dcapacity = self.txtDcapacity.value()
239 256
240 257
241 258 @pyqtSignature("int") #CLOSED
242 259 def on_lstDcapacity_activated(self, index):
243 260 """
244 261 Permite elegir el tamaΓ±o del disco
245 262 """
246 263 if index == 0:
247 264 var_size=25.0
248 265 elif index == 1:
249 266 var_size=8.5
250 267 elif index == 2:
251 268 var_size=4.7
252 269 elif index == 3:
253 270 var_size=0.7
254 271
255 272 if index != 4:
256 273 self.txtDcapacity.setValue(var_size*10**9/1024**2)
257 274 self.txtDcapacity.setReadOnly(True)
258 275 else:
259 276 self.txtDcapacity.setValue(100.0)
260 277 self.txtDcapacity.setReadOnly(False)
261 278
262 279 self.var_lstDcapacity = self.lstDcapacity.currentIndex()
263 280 self.var_Dcapacity = self.txtDcapacity.value()
264 281
265 282
266 283 #==============================================================================
267 284 # Botones para la generacion de los archivos de configuracion y el proceso de grabacion
268 285 #==============================================================================
269 286
270 287 #----------------------------------------------------- Generacion de la configuracion usando los parametros ---------------------------------------------------------------
271 288
272 289 @pyqtSignature("")
273 290 def on_btnGbkp_clicked(self):
274 291 """
275 292 Generacion de archivos de configuracion usando los parametros
276 293 """
277 294
278 295 if functions.validate_parameters(self) == False:
279 296 return
280 297
281 298 #Crea las carpetas en la ruta del proyecto y verifica que se crearon correctamente
282 299 list_dirs=['gpath','iso','ppath', 'tmpdata']
283 300 bool_make_dirs = functions.make_dirs(list_dirs, self)
284 301 if bool_make_dirs == False:
285 302 return
286 303
287 304 var_files_list = functions.list_files(self) #Se obtiene la lista de archivos a grabar
288 305
289 306 self.var_Discs = functions.make_files_dat(var_files_list, self) #Se crean los archivos .dat
290 307
291 308 functions.make_files_print(self) # Se crean los archivos .print
292 309
293 310 functions2.make_parameters_conf(self) # se crea el archivo parameters.conf
294 311
295 312 self.txtInfo.append("Total number of discs for recording: "+str(self.var_Discs * self.var_Copys))
296 313
297 314 #Se bloquean los parametros de configuracion
298 315 functions2.enabled_items1(True, self)
299 316
300 317
301 318
302 319 #----------------------------------------------------- Permite reiniciar la configuracion ---------------------------------------------------------------
303 320
304 321 @pyqtSignature("")
305 322 def on_btnRestart_clicked(self):
306 323 """
307 324 Permite que se puedan cambiar los parametros
308 325 """
309 326 functions2.enabled_items1(False, self)
310 327 os.remove("parameters.conf")
311 328
312 329
313 330 #----------------------------------------------------- Iniciar proceso de grabacion ---------------------------------------------------------------
314 331
315 332 @pyqtSignature("")
316 333 def on_btnStartburn_clicked(self):
317 334 """
318 335 Se inicia el proceso de grabacion
319 336 """
320 337
321 338 if self.blank_discs == True:
322 339 self.btnStartburn.setEnabled(False)
323 340 self.burning()
324 341 return
325 342
326 343 #Verifica que exista algun dispositivo de grabacion seleccionado
327 344 if not(functions2.selected_devices(self)):
328 345 self.txtInfo.append("There is no recording device selected")
329 346 return
330 347
331 348 #Lista los dispositivos de grabacion a usar
332 349 for dev in self.var_devices:
333 350 self.txtInfo.append("recording device :"+dev)
334 351
335 352 #Asigna las variables con los valores iniciales
336 353 self.var_disc_n = 0 # numero de disco actual para grabacion
337 354 self.var_copy_n = 0
338 355 self.var_step = 0
339 356 self.bool_state_burning = True
340 357 self.blank_discs = False
341 358
342 359 functions2.enabled_items2(True, self)
343 360 self.burning()
344 361
345 362 def burning(self):
346 363
347 364 var_Rpath_ppath=self.var_Rpath+"/ppath"
348 365 var_Rpath_iso=self.var_Rpath+"/iso"
349 366
350 367 #Creacion del archivo.iso para la grabacion
351 368 if self.var_step == 0:
352 369 #borra la imagen.iso del numero de disco anterior
353 370 if self.var_disc_n > 0:
354 371 file_iso=var_Rpath_iso+"/"+functions.i2s(self.var_disc_n)+".iso"
355 372 # os.remove(file_iso)
356 373
357 374 self.var_disc_n += 1 # aumenta numero de disco actual para grabacion
358 375 self.var_copy_n = 0 # Resetea el numero actual de la copia
359 376
360 377 #Si ya se grabaron todos los discos
361 378 if self.var_disc_n > self.var_Discs:
362 379 self.bool_state_burning = False
363 380 self.txtInfo.append("Recording process is complete")
364 381 # functions2.eject_devices(self) # Expulsa las bandejas de los dispostivos de grabacion
365 382
366 383 return
367 384
368 385 self.txtInfo.append("########## DISCO NUMERO: "+str(self.var_disc_n)+"##########")
369 386 self.txtInfo.append("--------Creando el iso del disco numero: "+str(self.var_disc_n))
370 387
371 388 #comando para la creacion del archivo.iso
372 389 file_dat=var_Rpath_ppath+"/"+self.var_Elabel+"_"+functions.i2s(self.var_disc_n)+".dat"
373 390 file_iso=var_Rpath_iso+"/"+functions.i2s(self.var_disc_n)+".iso"
374 391 var_cmd = 'genisoimage -hide-joliet-trans-tbl -joliet-long -r '
375 392 var_cmd += ' -A '+self.var_Elabel+' -V '+self.var_Elabel
376 393 var_cmd += ' -graft-points -path-list '+ file_dat+' -o '+file_iso
377 394 self.var_step = 1 #Se ira al paso de la grabacion en la siguiente llamada
378 395
379 396 #Grabacion de los DVDs
380 397 elif self.var_step == 1:
381 398 self.var_copy_n += 1 # numero de copia actual
382 399 var_index = ( ( (self.var_disc_n - 1) * self.var_Copys) + (self.var_copy_n - 1) ) % len(self.var_devices)
383 400
384 401 if var_index == 0 and self.blank_discs == False:
385 402 self.txtInfo.append("EXPULSANDO BANDEJAS")
386 403 self.var_copy_n -= 1 #El numero de copia se regresa al estado anterior
387 404 # functions2.eject_devices(self) # Expulsa las bandejas de los dispostivos de grabacion
388 405 self.blank_discs = True
389 406 self.btnStartburn.setText("Continue")
390 407 self.btnStartburn.setEnabled(True)
391 408 return
392 409
393 410 self.blank_discs = False
394 411
395 412 self.txtInfo.append("Grabando la copia numero: "+str(self.var_copy_n))
396 413 #Si esta es la ultima copia se pasara al siguiente disco en la siguiente llamada a la funcion
397 414 if self.var_copy_n == self.var_Copys:
398 415 self.var_step = 0
399 416
400 417 var_dev_tmp = self.var_devices[var_index]
401 418 file_iso=var_Rpath_iso+"/"+functions.i2s(self.var_disc_n)+".iso"
402 419 var_cmd = "wodim -v dev="+var_dev_tmp+" speed=16 "+ file_iso
403 420
404 421 self.var_process.start('ls')
405 422 self.txtInfo.append("CMD: "+var_cmd)
406 423
407 424 # self.txtInfo.append("creando iso")
408 425 # self.var_process.start(var_cmd)
409 426
410 427
411 428 #----------------------------------------------------- Detener proceso de grabacion ---------------------------------------------------------------
412 429
413 430 @pyqtSignature("")
414 431 def on_btnStopburn_clicked(self):
415 432 """
416 433 Slot documentation goes here.
417 434 """
418 435 self.bool_state_burning = False
419 436 self.var_process.terminate() #Termina el proceso, si puede
420 437 # self.var_process.kill() #Mata el proceso, no es la forma adecuada, solo usar si terminate() no funciona
421 438 self.txtInfo.append("Stopped recording")
422 439 functions2.enabled_items2(False, self)
423 440 self.btnStartburn.setText("Start Burn")
424 441
425 442
426 443 #----------------------------------------------------- Testeo de las unidades de grabacion ---------------------------------------------------------------
427 444
428 445 @pyqtSignature("")
429 446 def on_btnTdevA_clicked(self):
430 447 var_dev = str(self.txtDeviceA.text())
431 448 var_cmd = 'eject ' + var_dev + '; eject -t ' + var_dev
432 449 commands.getstatusoutput(var_cmd)
433 450
434 451 @pyqtSignature("")
435 452 def on_btnTdevB_clicked(self):
436 453 var_dev = str(self.txtDeviceB.text())
437 454 var_cmd = 'eject ' + var_dev + '; eject -t ' + var_dev
438 455 commands.getstatusoutput(var_cmd)
439 456
440 457 @pyqtSignature("")
441 458 def on_btnTdevC_clicked(self):
442 459 var_dev = str(self.txtDeviceC.text())
443 460 var_cmd = 'eject ' + var_dev + '; eject -t ' + var_dev
444 461 commands.getstatusoutput(var_cmd)
445 462
446 463 @pyqtSignature("")
447 464 def on_btnTdevD_clicked(self):
448 465 var_dev = str(self.txtDeviceD.text())
449 466 var_cmd = 'eject ' + var_dev + '; eject -t ' + var_dev
450 467 commands.getstatusoutput(var_cmd)
451 468
452 469 @pyqtSignature("")
453 470 def on_btnTDpath_clicked(self):
454 471 """
455 472 Slot documentation goes here.
456 473 """
457 474 self.var_TDpath= str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
458 475 self.txtTDpath.setText(self.var_TDpath)
459 476 self.statusTDpath = functions.dir_exists(self.var_TDpath, self)
460 477
461 478
462 479 @pyqtSignature("")
463 480 def on_btnCHstart_clicked(self):
464 481 """
465 482 Slot documentation goes here.
466 483 """
467 484 pass
General Comments 0
You need to be logged in to leave comments. Login now