##// END OF EJS Templates
jro_apps » bk_manager
RSS
***
ralonso -
r47:48
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,213 +1,216
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
12 12
13 13 #Entero a cadena agregando ceros delante
14 14 def i2s(var_n, var_length=4):
15 15 var_n2=str(var_n)
16 16 while len(var_n2) < var_length:
17 17 var_n2 = "0"+var_n2
18 18 return var_n2
19 19
20 20
21 21 #Crea directorios en la ruta indicada
22 22 def make_dirs(list_dirs, self):
23 23 var_cmd="mkdir -p "+str(self.var_Rpath)
24 24 for var_dir in list_dirs:
25 25 var_output=commands.getstatusoutput(var_cmd+'/'+var_dir)[0]
26 26 if var_output != 0:
27 27 self.txtInfo.append("Error al crear el directorio "+var_dir+", output_error:" + str(var_output))
28 28 return False
29 29 self.txtInfo.append('Carpetas creadas correctamente')
30 30 return True
31 31
32 32
33 33 #Se verifica que la ruta exista y sea un directorio
34 34 def dir_exists(var_dir, self):
35 35 var_cmd="test -d "+str(var_dir)
36 36 var_output=commands.getstatusoutput(var_cmd)[0]
37 37 if var_output != 0:
38 38 self.txtInfo.append("Ruta no valida, output_error:" + str(var_output))
39 39 return False
40 40 else:
41 41 self.txtInfo.append("Ruta valida, sin error:" + str(var_dir))
42 42 return True
43 43
44 44
45 45 #Se buscan los archivos del tipo especificado
46 46 def load_days(self):
47 47
48 48 self.var_list=[]
49 49 self.lstStartDay.clear()
50 50 self.lstStopDay.clear()
51 51
52 52 if self.statusDpath == False:
53 53 self.btnGbkp.setEnabled(False)
54 54 return
55
56 if self.var_Dtype == '':
57 return
55 58
56 59 var_cmd="find " + str(self.var_Dpath) + " -name *."+ str(self.var_Dtype) +" | awk -F/ '{print substr($NF,2,7)}' | sort| uniq"
57 60 output=commands.getstatusoutput(var_cmd)[1]
58 61
59 62 #Si no se encuentra ningun archivo
60 63 if len(output) == 0:
61 64 self.txtInfo.append("No se encontraron archivos")
62 65 self.btnGbkp.setEnabled(False)
63 66 return
64 67
65 68 #Se cargan las listas para seleccionar StartDay y StopDay (QComboBox)
66 69 for i in range(0, (len(output)+1)/8):
67 70 self.var_list.append(output[8*i:8*(i+1)-1])
68 71
69 72 for i in self.var_list:
70 73 self.lstStartDay.addItem(i)
71 74 self.lstStopDay.addItem(i)
72 75 self.lstStopDay.setCurrentIndex(self.lstStartDay.count()-1)
73 76
74 77 get_sub_list(self)
75 78 self.btnGbkp.setEnabled(True)
76 79
77 80
78 81 #Verifica que los parametros
79 82 def validate_parameters(self):
80 83 #Verifica que las rutas sean validas
81 84 if self.statusRpath == False:
82 85 self.txtInfo.append("Ruta de proyecto no valida")
83 86 return False
84 87
85 88 #Verifica la etiqueta
86 89 if len(self.var_Elabel) == 0:
87 90 self.txtInfo.append("Debe ingresar el nombre de la etiqueta")
88 91 return False
89 92
90 93 return True
91 94
92 95
93 96 #Obtiene el rango de las fechas seleccionadas
94 97 def get_sub_list(self):
95 98 self.var_sublist=[]
96 99 for i in self.var_list[self.lstStartDay.currentIndex():self.lstStartDay.currentIndex() + self.lstStopDay.currentIndex()+1]:
97 100 self.var_sublist.append(i)
98 101 if len(self.var_sublist) == 0:
99 102 self.txtInfo.append("No existen archivos encontrados")
100 103
101 104
102 105 #Busca los archivos con los parametros de busqueda
103 106 def list_files(self):
104 107 var_files_list=[]
105 108 for var_doy in self.var_sublist:
106 109 var_cmd="find " + str(self.var_Dpath) + " -name ?"+var_doy+"???."+ str(self.var_Dtype) + " |sort"
107 110 var_output=commands.getstatusoutput(var_cmd)[1]
108 111 for var_file in var_output.split():
109 112 var_files_list.append(var_file) #Almacena cada archivo en la lista
110 113 return var_files_list
111 114
112 115
113 116 #Genera la lista de archivos .dat que contienen los archivos a grabar en cada DVD
114 117 def make_files_dat(var_files_list, self):
115 118 var_Rpath_ppath=self.var_Rpath+"/ppath" #Ruta de los archivos a grabar
116 119 var_n=1 #Numero del DVD actual
117 120 var_tmp=0 #Se usa para acumular el tamaΓ±o de los archivos de la lista
118 121 var_files_list_2=[] #Se usa para almacenar la lista de archivos agrbar en cada DVD
119 122
120 123 for i in var_files_list: #Se asignan en i los archivos de la lista
121 124 self.txtInfo.append(i)
122 125 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
123 126 var_tmp += var_size_i #Se acumulan el tamaΓ±o de los archivos de la lista
124 127
125 128 #Si el tamaΓ±o acumulado es mayor que el de el DVD
126 129 if var_tmp > self.var_Dcapacity:
127 130 var_tmp -= var_size_i #se quita el tamaΓ±o sumado para mostrar el tamaΓ±o real
128 131 #se crea un archivo con numeral en el sufijo y extension .dat
129 132 var_file = open(var_Rpath_ppath+"/"+self.var_Elabel+"_"+i2s(var_n)+".dat","w")
130 133 #Se aΓ±ade la lista de archivos a grabar en el DVD al archivo .dat
131 134 for line in var_files_list_2:
132 135 var_tmp_path=(line.split(self.var_Dpath)[1]).split('/')
133 136 var_tmp_path2="/"
134 137 for l in range(0, len(var_tmp_path)-1):
135 138 var_tmp_path2=var_tmp_path2+str(var_tmp_path[l])+"/"
136 139 var_file.write(var_tmp_path2+'=')
137 140 var_file.write(line+'\n')
138 141 var_file.close()
139 142
140 143 var_tmp = var_size_i #Se asigna a la variable el tamaΓ±o del archivo actual
141 144 var_files_list_2=[] #Se reinicia la lista
142 145 var_n += 1
143 146 var_files_list_2.append(i)
144 147
145 148 #se crea un archivo con numeral en el sufijo y extension .dat
146 149 var_file = open(var_Rpath_ppath+"/"+self.var_Elabel+"_"+i2s(var_n)+".dat","w")
147 150 #Se aΓ±ade la lista de archivos a grabar en el DVD al archivo .dat
148 151 for line in var_files_list_2:
149 152 var_tmp_path=(line.split(self.var_Dpath)[1]).split('/')
150 153 var_tmp_path2="/"
151 154 for l in range(0, len(var_tmp_path)-1):
152 155 var_tmp_path2=var_tmp_path2+str(var_tmp_path[l])+"/"
153 156 var_file.write(var_tmp_path2+'=')
154 157 var_file.write(line+'\n')
155 158 var_file.close()
156 159
157 160 return var_n
158 161
159 162
160 163 #Genera los archivos .print con los cuales se creara los postscript
161 164 def make_files_print(self):
162 165
163 166 var_Rpath_ppath=self.var_Rpath+"/ppath" #Ruta de los archivos a grabar
164 167
165 168 # Se leen todos los archivos .dat creados para crear las etiquetas en los archivos .print
166 169 for var_n in range(1, self.var_n_discs + 1):
167 170 #se abren los archivos .dat en modo lectura
168 171 var_file = open(var_Rpath_ppath+"/"+self.var_Elabel+"_"+i2s(var_n)+".dat","r")
169 172 lines=var_file.readlines() # Se lee las lineas en el archivo y se almacenan en la lista
170 173 # Se crea el archivo .print
171 174 var_file_print = open(var_Rpath_ppath+"/"+self.var_Elabel+"_"+i2s(var_n)+".print","w")
172 175 var_file_print.write(self.var_Elabel+" "+i2s(var_n)+"/"+i2s(self.var_n_discs)+"\n")
173 176 var_file_print.write("Year Doy Folder Set Time range\n")
174 177
175 178 var_first_folder = lines[0].split('=')[0]
176 179 var_first_file = (lines[0].split('=')[1])[:-1]
177 180 var_date_first_file=commands.getstatusoutput("date -r "+var_first_file+" +'%T'")[1]
178 181
179 182 for j in range(1, len(lines)-1):
180 183 var_tmp_folder = lines[j].split('=')[0]
181 184 var_tmp_file = (lines[j].split('=')[1])[:-1]
182 185
183 186 # Si el subfolder superior o la fecha del archivo cambia se genera una nueva linea
184 187 if (var_tmp_folder != var_first_folder) or (var_tmp_file[0:-5] != var_first_file[0:-5]):
185 188 var_last_file = (lines[j-1].split('=')[1])[:-1]
186 189 var_date_last_file=commands.getstatusoutput("date -r "+var_last_file+" +'%T'")[1]
187 190 # Si el archivo se grabara directamente en la / del DVD y no en un /directorio/
188 191 # se usa la etiqueta para indicar la parte de la etiqueta donde va el subdirectorio
189 192 if var_first_folder == '/':
190 193 var_folder = self.var_Elabel
191 194 else:
192 195 var_folder = var_first_folder.split('/')[1]
193 196
194 197 var_file_print.write(var_first_file[-12:-8]+" "+var_first_file[-8:-5]+" "+var_folder +" "+var_first_file[-5:-2]+" "
195 198 +var_last_file[-5:-2]+" "+var_date_first_file+" "+var_date_last_file+"\n")
196 199
197 200 var_first_folder = lines[j].split('=')[0]
198 201 var_first_file = (lines[j].split('=')[1])[:-1]
199 202 var_date_first_file=commands.getstatusoutput("date -r "+var_first_file+" +'%T'")[1]
200 203
201 204 var_last_file = (lines[-1].split('=')[1])[:-1]
202 205 var_date_last_file=commands.getstatusoutput("date -r "+var_last_file+" +'%T'")[1]
203 206
204 207 if var_first_folder == '/':
205 208 var_folder = self.txtElabel.text()
206 209 else:
207 210 var_folder = var_first_folder.split('/')[1]
208 211
209 212 var_file_print.write(var_first_file[-12:-8]+" "+var_first_file[-8:-5]+" "+var_folder +" "+var_first_file[-5:-2]+" "
210 213 +var_last_file[-5:-2]+" "+var_date_first_file+" "+var_date_last_file+"\n")
211 214
212 215 var_file.close()
213 216 var_file_print.close()
Show file before | Show file after | Hide comments
@@ -1,316 +1,308
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 Ui_MainWindow import Ui_MainWindow
10 10 from PyQt4 import QtGui
11 11 from subprocess import *
12 12 import sys
13 13 import os
14 14 import subprocess
15 15 import commands
16 16 from functions import functions
17 17 from functions import functions2
18 18
19 19 class MainWindow(QMainWindow, Ui_MainWindow):
20 20 """
21 21 Class documentation goes here.
22 22 """
23 23
24 24 def __init__(self, parent = None):
25 25 QMainWindow.__init__(self, parent)
26 26 self.setupUi(self)
27 27 self.setupUi2()
28 28 sys.stdout = self #redirige salida estandar
29 29
30 30 def setupUi2(self):
31 31
32 32 self.statusDpath = False
33 33 self.statusRpath = False
34 34
35 35 functions2.set_parameters(self) #Establece ciertos parametros, para pruebas
36 36
37 37 self.var_Dpath = self.txtDpath.text()
38 38 self.var_Rpath = self.txtRpath.text()
39 39 self.var_Dtype = self.txtDtype.text()
40 40 self.var_Elabel = self.txtElabel.text()
41 41 self.var_Copys = self.txtCopys.value()
42 42 self.var_Dcapacity = self.txtDcapacity.value() * 1024
43
43
44 44 self.var_n_discs=0
45 45 self.var_list=[]
46 46 self.var_sublist=[]
47 47
48 48 functions2.detect_devices(self) #busca los dispositivos de grabacion
49 functions.load_days(self)
50
49 51
50 52
51 53 def write(self, txt):
52 54 """
53 55 Escribe la salida estandar eb txtInfo
54 56 """
55 57 self.txtInfo.append(str(txt))
56 58
57 59
58 60 @pyqtSignature("")
59 61 def on_btnDpath_clicked(self):
60 62 """
61 63 Permite seleccionar graficamente el direcorio de los datos a grabar
62 64 """
63 65 self.var_Dpath= QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly)
64 66 self.txtDpath.setText(self.var_Dpath)
65 67 self.on_txtDpath_editingFinished() #llamada a funcion
66 68
67 69
68 70 @pyqtSignature("")
69 71 def on_btnRpath_clicked(self):
70 72 """
71 73 Permite seleccionar graficamente el direcorio del proyecto
72 74 """
73 75 self.var_Rpath = QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly)
74 76 self.txtRpath.setText(self.var_Rpath)
75 77 self.on_txtRpath_editingFinished() #llamada a funcion
76 78
77 79
78 80 @pyqtSignature("")
79 81 def on_txtDpath_editingFinished(self):
80 82 """
81 83 Permite buscar los archivos de extension seleccionada en la ruta de de datos
82 84 y cargar los valores para el rango de tiempo a ser grabado
83 85 """
84 86 self.var_Dpath=self.txtDpath.text() #Se carga la variable con la ruta recien editada
85 87 self.statusDpath = functions.dir_exists(self.var_Dpath, self)
86 88 functions.load_days(self)
87 89
88 90
89 91 @pyqtSignature("")
90 92 def on_txtRpath_editingFinished(self):
91 93 """
92 94 Valida la ruta del proyecto
93 95 """
94 96 self.var_Rpath=self.txtRpath.text() #Se carga la variable con la ruta recien editada
95 97 self.statusRpath = functions.dir_exists(self.var_Rpath, self)
96 98
97 99
98 100 @pyqtSignature("int")
99 101 def on_lstDtype_activated(self, index):
100 102 """
101 103 Permite elegir entre los tipos de archivos
102 104 """
105 self.txtDtype.setReadOnly(True)
103 106 if index == 0:
104 107 var_type='r'
105 108 elif index == 1:
106 109 var_type='pdata'
107 110 elif index == 2:
108 111 var_type='sswma'
109
110 if index != 3:
111 self.txtDtype.setText(var_type)
112 self.txtDtype.setReadOnly(True)
113 self.var_Dtype=self.txtDtype.text()
114 functions.load_days(self)
115
116 else:
117 self.txtDtype.setText('')
112 else :
113 var_type=''
118 114 self.txtDtype.setReadOnly(False)
119
115
116 self.txtDtype.setText(var_type)
117 self.on_txtDtype_editingFinished()
118
120 119
121 120 @pyqtSignature("")
122 121 def on_txtDtype_editingFinished(self):
123 122 self.var_Dtype=self.txtDtype.text()
124 123 functions.load_days(self) #llamada a funcion
125 124
126 125
127 126 @pyqtSignature("")
128 127 def on_txtElabel_editingFinished(self):
129 128 self.var_Elabel = self.txtElabel.text()
130 129
131 130
132 131 @pyqtSignature("")
133 132 def on_txtCopys_editingFinished(self):
134 133 self.var_Copys = self.txtCopys.value()
135 134
136 135
137 136 @pyqtSignature("")
138 137 def on_txtDcapacity_editingFinished(self):
139 138 self.var_Dcapacity = self.txtDcapacity.value() * 1024 #tamaΓ±o en KB
140 139
141 140
142 141 @pyqtSignature("int") #CLOSED
143 142 def on_lstStartDay_activated(self, index):
144 143 """
145 144 Cambia la lista de opciones en lstStopDay
146 145 """
147 146 var_StopDay_index=self.lstStopDay.count() - self.lstStopDay.currentIndex()
148 147 self.lstStopDay.clear()
149 148
150 149 for i in self.var_list[index:]:
151 150 self.lstStopDay.addItem(i)
152 151
153 152 self.lstStopDay.setCurrentIndex(self.lstStopDay.count() - var_StopDay_index)
154 153
155 154 functions.get_sub_list(self)
156 155
157 156
158 157 @pyqtSignature("int") #CLOSED
159 158 def on_lstStopDay_activated(self, index):
160 159 """
161 160 Cambia la lista de opciones en lstStartDay
162 161 """
163 162 var_StartDay_index=self.lstStartDay.currentIndex()
164 163 var_end_index = self.lstStopDay.count() - index
165 164 self.lstStartDay.clear()
166 165
167 166 for i in self.var_list[:len(self.var_list) - var_end_index + 1]:
168 167 self.lstStartDay.addItem(i)
169 168
170 169 self.lstStartDay.setCurrentIndex(var_StartDay_index)
171 170
172 171 functions.get_sub_list(self)
173 172
174 173
175 174 @pyqtSignature("int") #CLOSED
176 175 def on_lstDcapacity_activated(self, index):
177 176 """
178 177 Permite elegir el tamaΓ±o del disco
179 178 """
180 179 if index == 0:
181 180 var_size=25.0
182 181 elif index == 1:
183 182 var_size=8.5
184 183 elif index == 2:
185 184 var_size=4.7
186 185 elif index == 3:
187 186 var_size=0.7
188 187
189 188 if index != 4:
190 189 self.txtDcapacity.setValue(var_size*10**9/1024**2)
191 190 self.txtDcapacity.setReadOnly(True)
192 191 else:
193 192 self.txtDcapacity.setValue(100.0)
194 193 self.txtDcapacity.setReadOnly(False)
195 194
196 195 self.var_Dcapacity = self.txtDcapacity.value() * 1024 #tamaΓ±o en KB
197 196
198 197
199 198 @pyqtSignature("")
200 199 def on_btnGbkp_clicked(self):
201 200 """
202 201 Cuando se presiona el boton btnGbkp
203 202 """
204 203
205 204 if functions.validate_parameters(self) == False:
206 205 return
207 206
208 207 #Crea las carpetas en la ruta del proyecto y verifica que se crearon correctamente
209 208 list_dirs=['gpath','iso','ppath']
210 209 bool_make_dirs = functions.make_dirs(list_dirs, self)
211 210 if bool_make_dirs == False:
212 211 return
213 212
214 213 var_files_list = functions.list_files(self) #Se obtiene la lista de archivos a grabar
215 214 self.var_n_discs = functions.make_files_dat(var_files_list, self) #Se crean los archivos .dat
216 215
217 216 functions.make_files_print(self) # Se crean los archivos .print
218 217
219 218 #Se deshabilita el Tab Parameters y el boton btnGbkp
220 219 self.tabParameters.setEnabled(False)
221 220 self.lstDcapacity.setEnabled(False)
222 221 self.txtDcapacity.setEnabled(False)
223 222 self.btnGbkp.setEnabled(False)
224 223 self.btnRestart.setEnabled(True)
225 224 self.btnStartburn.setEnabled(True)
226 225
227 226
228 227 @pyqtSignature("")
229 228 def on_btnRestart_clicked(self):
230 229 """
231 230 Permite que se puedan cambiar los parametros
232 231 """
233 232 self.tabParameters.setEnabled(True)
234 233 self.lstDcapacity.setEnabled(True)
235 234 self.txtDcapacity.setEnabled(True)
236 235 self.btnGbkp.setEnabled(True)
237 236 self.btnRestart.setEnabled(False)
238 237 self.btnStartburn.setEnabled(False)
239 238
240 239
241 240 @pyqtSignature("")
242 241 def on_btnStartburn_clicked(self):
243 242 """
244 243 Se inicia el proceso de grabacion
245 244 """
246 245 self.btnRestart.setEnabled(False)
247 246 self.btnStartburn.setEnabled(False)
248 247 self.btnStopburn.setEnabled(True)
249 248
250 return
251
252 249 sys.stdout = self
253 250 #sys.stderr = self
254 251 print "stdout_!!!"
255 252
256 253 #Inicializando variables
257 var_Rpath=self.txtRpath.text()
258 var_Rpath_ppath=var_Rpath+"/ppath"
259 var_Rpath_iso=var_Rpath+"/iso"
260 var_label=self.txtElabel.text()
261
254 var_Rpath_ppath=self.var_Rpath+"/ppath"
255 var_Rpath_iso=self.var_Rpath+"/iso"
256
262 257 # Se leen todos los archivos .dat creados para crear las etiquetas en los archivos .ps
263 for var_n in range(0, self.var_n_discs+1):
264 print var_n
265
258 for var_n in range(1, self.var_n_discs+1):
259 self.txtInfo.append(str(var_n))
266 260 file_iso=var_Rpath_iso+"/"+functions.i2s(var_n)+".iso"
267 file_dat=var_Rpath_ppath+"/"+self.txtElabel.text()+"_"+functions.i2s(var_n)+".dat"
261 file_dat=var_Rpath_ppath+"/"+self.var_Elabel+"_"+functions.i2s(var_n)+".dat"
268 262
269 263 var_cmd = 'genisoimage -hide-joliet-trans-tbl -joliet-long -r '
270 var_cmd += ' -A '+var_label+' -V '+var_label
264 var_cmd += ' -A '+self.var_Elabel+' -V '+self.var_Elabel
271 265 var_cmd += ' -graft-points -path-list '+ file_dat+' -o '+file_iso
272 266 self.txtInfo.append(var_cmd)
273
274 var_output=commands.getstatusoutput(str(var_cmd))[0]
275 self.txtInfo.append(str(var_output))
276
267 #
268 # var_output=commands.getstatusoutput(str(var_cmd))[0]
269 # self.txtInfo.append(str(var_output))
270 #
277 271 #os.system(str(var_cmd))
278 272 #p = subprocess.Popen(str('ls /'), shell=True, stdout=self)
279 273 #os.waitpid(p.pid, 0)
280 274 ####self.txtInfo.append(str(p.pid))
281 275
282 276
283 277 @pyqtSignature("")
284 278 def on_btnStopburn_clicked(self):
285 279 """
286 280 Slot documentation goes here.
287 281 """
288 282 self.btnRestart.setEnabled(True)
289 283 self.btnStartburn.setEnabled(True)
290 284 self.btnStopburn.setEnabled(False)
291 285
292 286 @pyqtSignature("")
293 287 def on_btnTdevA_clicked(self):
294 288 var_dev = str(self.txtDeviceA.text())
295 289 var_cmd = 'eject ' + var_dev + '; eject -t ' + var_dev
296 290 commands.getstatusoutput(var_cmd)
297 291
298 292 @pyqtSignature("")
299 293 def on_btnTdevB_clicked(self):
300 294 var_dev = str(self.txtDeviceB.text())
301 295 var_cmd = 'eject ' + var_dev + '; eject -t ' + var_dev
302 296 commands.getstatusoutput(var_cmd)
303 297
304 298 @pyqtSignature("")
305 299 def on_btnTdevC_clicked(self):
306 300 var_dev = str(self.txtDeviceC.text())
307 301 var_cmd = 'eject ' + var_dev + '; eject -t ' + var_dev
308 302 commands.getstatusoutput(var_cmd)
309 303
310 304 @pyqtSignature("")
311 305 def on_btnTdevD_clicked(self):
312 306 var_dev = str(self.txtDeviceD.text())
313 307 var_cmd = 'eject ' + var_dev + '; eject -t ' + var_dev
314 308 commands.getstatusoutput(var_cmd)
315
316
General Comments 0
You need to be logged in to leave comments. Login now