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