Mensajes

Buenas!
Disculpa las molestias cuando hice el finally que dentro hay otro try, debe de haber un except no otro finally, por la cual se debe quedar así

Código (python) [Seleccionar] Expandir


  finally:
     try:
         cursor.close()
         db.close()
     except:
        None

Pues queremos que si hay conexion se cierre y sino no hace nada.
Además da error porque requiere del modulo pymysql, cuyo modulo no has importado en ningun sitio

Código (python) [Seleccionar] Expandir


import pymysql


Si no lo tienes instalado, lo puedes instalar haceindo

pip3 install pymysql

Buenas fiestas, y espero que te haya ayudado y te salga...Suerte 

[RECOMENDACION: Elimina los datos de conexion de DB, ya que han sido probados, no te interesa que cualquiera pueda entrar. Auque no sea relevante para ti, y solo es de prueba. Además esta entrando como root y algúien podría eliminar la DB del hosting y liartela....]

Buenos dias!

RECOMENDACION: Elimina los datos de conexion de DB, ya que han sido probados, no te interesa que cualquiera pueda entrar. Auque no sea relevante para ti, y solo es de prueba. Además esta entrando como root y algúien podría eliminar la DB del hosting y liartela....

Con tu permiso, he entrado en tu DB y he comprobado que funciona correctamente. (solo he insertado unos datos en la tabla test1 y lo he vaciado sus registros)

No habia caido en que al hacer la funcion crearCliente()

Código (python) [Seleccionar] Expandir


def crearCliente():
crearCliente = "INSERT INTO test1(name,email) VALUES ('prueba','prueba')"  
ttk.Label(mainframe, text="Haz creado un cliente").grid(column=40, row=150, sticky=W)


No lo estas ejecutando en ninguna DB . Pues indicas el SQL pero no haces nada con el. Primero deberias de crear la conexion (como lo hicistes en conexion.py) y después ejecutar la variable crearCliente. Quedaria algo así

Código (python) [Seleccionar] Expandir


def crearCliente():
  try:
       db = pymysql.connect(....)
       cursor = db.cursor()
crearCliente = "INSERT INTO test1(name,email) VALUES ('prueba','prueba')"
       cursor.execute(crearCliente)
ttk.Label(mainframe, text="Haz creado un cliente").grid(column=40, row=150, sticky=W)
  except:
       ttk.Label(mainframe, text="Error en la DB").grid(column=40, row=150, sticky=W)
  finally:
     try:
         cursor.close()
         db.close()
     finally:
        None


Ademas pondría un try/catch por si hay algun error en el SQL/conexion,etc....

Además le añado un finally para asegurar que siempre se me cierra la conexion, de un error o no.

Espero haberte ayudado y  felices fiestas  

Bunos dias!

Me alegro que hayas podido mejorar en crear la tabla con PK y id autoincrementado.
Por lo que veo, esta todo bién. Me gustaría ver el archivo conexion.py pues puede que este fallando algo.

Ten en cuenta que si estas trabajando con un Web Hosting, este en su panel te dará la direccion al que tienes que ir. Puedo intuir que deberia estar así actualmente tu conexion.py

Código (python) [Seleccionar] Expandir


import pymysql

# Abre conexion con la base de datos
db = pymysql.connect(host='freemysqlhosting.net',
                             user='root',
                             password='root',
                             database='test',
                             charset='utf8mb4',
                             cursorclass=pymysql.cursors.DictCursor)
# [...]


Esto es un ejemplo, para saberlo tendrías que mirar en tu CPanel de tu proveedor de Hosting web. Un ejemplo sería:

https://imgur.com/gallery/itKoNsD

Ten en cuenta: que es este caso el host es 260mb.net pero para conexion con DB es sql113.260mb.net. Puede que el tuyo también sea algo así.

Espero haberte ayudado! Buenas fiestas y que te lo pases bien!

[¿Porque falla y como solucionarlo?]

Buenos dias.
¿Porque falla y como solucionarlo?

Código (python) [Seleccionar] Expandir


# Seleccionador base de datos
def crearCliente():
    crearCliente1 = "INSERT INTO test(id,name,email) VALUES ('5','prueba','prueba')"


El problema esta en la sentencia SQL.
La sintaxis es correcta pero los tipos de datos asociados de la columna no cuadran.

El id es una columna PRIMARY KEY, que identifica ese registro en concreto. Este normalmente es auto incremental que por cada insert que tu hagas este se incrementa.
El tipo de dato para un id autoincrementado es INT.

Como es INT (integer=entero), es un numero, por la cual no puedes añadir en el VALUES un '5', sino un 5.

El '5' no es igual a 5.
'5' con comillas simples ( ' ) o comillas dobles ( " ) significa que es un VARCHAR(), texto
5 (sin comillas) es un numero.


Propuesta de mejora

Configuraria en el gestor de bases de datos que la columna id fuera autoincrementado.

Yo no se como creas las tablas...si lo haces por interfaz grafica o SQL. Pero en SQL sería....

Código (SQL) [Seleccionar] Expandir


CREATE TABLE test1 (
    id INT NOT NULL AUTO_INCREMENT,
    name VARCHAR(20) NOT NULL,
    email VARCHAR(100) NOT NULL,
    CONSTRAINT test_PK PRIMARY KEY (id)
);


Si es AUTOINCREMENT no hace falta que insertes el 5 cuando hacer el INSERT.

Código (SQL) [Seleccionar] Expandir


INSERT INTO test(name,email) VALUES ('prueba','prueba');

Recomendacion de seguridad
Yo no recomiendo como programador de esta app, que este ataque a la base de datos con el usuario root.
El usuario ROOT es el que tiene más privilegios, por lo cual tiene también acceso a las otras DB, este no se suele usar para desarollo.
Crea otro usuario especifico y este que unicamente tenga acceso a la DB especifica test.

Código (sql) [Seleccionar] Expandir


CREATE USER 'test'@'localhost' IDENTIFIED BY 'root';
GRANT ALL PRIVILEGES ON test.* TO 'test'@'localhost';

La ultima sentencia le doy todos los permisos al usuario test que tenga acceso a la DB test.

De venir, viene en la BIOS.
No necesariamente más tiempo, si al menos más complejo, que esto luego redunde en más tiempo o no es otra cosa, aunque puede asumirse que suele ser así.

Lo que en realidad incide es en la incapacidad de recuperación exhaustiva en el sentido de completitud, es decir no será un rescate tan riguroso, y por tanto quedarán más lagunas sin poder ser resueltas (independientemente del tiempo empleado, pero en efecto a más tiempo se le dedique más probable que se rescaten datos).

Entiendo ok, muchas gracias a los dos.

Más dudas.....
Como hago un eliminado seguro de un carpeta...
yo lo hago así

Código [Seleccionar] Expandir

find ./carpeta -exec shred -uzv -n 10 {} +

Lo hago con find y shred, pero shred tiene internamente la posibilidad de eliminar de manera recursiva.....por curiosidad.....


Gracias por vuestra atencion y tiempo. Buenas noches.

Buenas! Si no he entendido mal de tu respuesta @XSStringManolo... 

Imagínate que eres pintor, pintas con spray desde 1 metro de distancia y tienes un cuadro. Pintaste un cuadro de rojo y lo quieres borrar escribiéndole uno verde encima. Le das una pasada de spray verde y habrás pintado una buena parte del rojo que había debajo, pero no lo pintaste todo. Es decir, ahora tienes rojo y verde mezclados. Si vuelves a darle otro chorro de spray desde un metro, habrás pintsod un poco mas del rojo de verde. Cuantas mas veces le des al spray, mas acabaras tapando el rojo con verde.

Cuando yo hago el shred -zu -n 10, tu similitud sería hacer como 10 pintadas en el cuadro....eso lo entiendo

Que pasa si solo le das una pintada y tapas bastante del rojo?

Esto sería el caso de que hiciera 1 pintada: shred -z -n 0. (por defecto hay uno, por la cual hago 0 pasadas opcionales + 1 que se hará por defecto)

Pues que pueden quedar las esquinas sin pintar, asique el que investigue, al ver las 4 esquinas y saber que es común pintar cuadrados, sabrá que a pesar de que pintaste de verde, antes había un cuadrado rojo ahí.

Si yo solo le hago una pasada, en un archivo que contiene 700K

Código [Seleccionar] Expandir


%PDF-1.4
%����
1 0 obj
<</Creator (Mozilla/5.0 \(X11; Linux x86_64\) AppleWebKit/537.36 \(KHTML, like Gecko\) Chrome/96.0.4664.45 Safari/5>
/Producer (Skia/PDF m96)
/CreationDate (D:20211212130932+00'00')
/ModDate (D:20211212130932+00'00')>>
endobj
3 0 obj
<</ca 1
/BM /Normal>>
endobj
13 0 obj
<</Type /XObject
/Subtype /Image
/Width 140
/Height 245
/ColorSpace /DeviceRGB
/BitsPerComponent 8
/Filter /DCTDecode
/ColorTransform 0
/Length 5982>> stream
����^@^PJFIF^@^A^A^A^@x^@x^@^@��^@C^@
^G^G    ^G^F
        ^H      ^K^K
^L^O^Y^P^O^N^N^O^^^V^W^R^Y$ &%# #"(-90(*6+"#2D26;=@@@&0FKE>J9?@=��^@C^A^K^K^K^O^M^O^]^P^P^]=)#)====================>
....

y al ejecutar shred -z -n 0, este me sobrescribiria el fichero a

Código [Seleccionar] Expandir


^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^...

que cuando más pasadas son más caracteres (^@) me genera....Estos caracteres random (sin ningun sentido) que unicamente sirve para "tapar"/sobreescribir los sectores de este archivo....
Haciendo que sea más dificil obtener el archivo original intactamente...


https://imgur.com/gallery/B5SJe2I

Por la cual si un perito forense obtiene este sector (todo el recuadro), unicamente vera el archivo corrupto o deformado....o que incluso se puede leer/abrir....

Al final, tu no escribes directamente en memoria, delegas en el sistema que lo haga él por eficiencia

Claro no lo escribes fisicamente sino que modificas los datos a la tabla de sistema de archivos, tanto el nombre como los datos. Y ya el sistema se encarga.

El formateo que hace por ejemplo windows, lo único que hace es borrar el sistema de ficheros y algunos archivos internos.

Esto cuando pasa, en un formateo rápido o formateo normal?

De hecho en los discos duros, hay una opción (típicamente no dispoonible/accesible al usuario), que permite indicar 'la fuerza' con que el disco duro escribe los datos. Cuanto más fuerte, más dificulta la lectura bajo él, pero también más fácil deja esa impresión para ser leída posteriormente, además, cuanto más fuerza se aplique con cada escritura, más se deteriora el disco,

Esto te refieres a los discos HDD, y como se puede acceder a esta opción no disponible por el usuario? En linux

Naturalmente no es asequible a cualquiera acceder al contenido previo, pero con paciencia (mucha paciencia) y la tecnología adecuada (un osciloscopio sería suficiente), pueden leerse varias copias previas (dicen que hasta 5), aunque asumo que esto último depende mucho de la tecnología empleada. Si no tienes registradas chorrocientas patentes, o eres multimillonario, ten por seguro que nadie va a perder tiempo en revisar lo que tenías escrito en tu disco duro, primeor porque no hay tanta gente que tenga la tecnología adecuada y segundo porque quienes la tienen la dedican a casos donde sea menester (que los contraten o ellos se autoempleen legal o ilegalmente).

En pocas palabrás, dices que cuando más sobreescrituras haces, más tiempo la persona interesada en sacar la informacion del HDD/SDD tardará en sacar la información e incluso este puede venir deformado.....Es así?

La salida que te ofrece, señala claramente en cada pasada el tipo de patrón utilizado...
luego lo que hace también es cambiar el nombre del fichero varias veces, antes de borrarlo de la tabla de ficheros (eliminación software), así también intenta que ni el nombre del mismo sea fácil de recuperar... para ser honestos, el nombre debiera ser remplazado primero por otro con la misma longitud que tiene el nombre actual... ahí me parece que empieza por uno mucho mas corto a la vista del nombre original (me edito, los '0' seguidos ocupan menos espacio y seguramente haya la misma cantidad de ceros que caracteres tiene el fichero.log).
Fíjate que en cada ocasión va acortando el nombre en un caracter menos.

Ok muchas gracias, ahora entiendo un poco mejor su significado.


Gracias a los dos @XSStringManolo y @Serapis, por la gran nivel de detalle al que se me ha respondido la duda. Muchas gracias.

Os he escrito así como más o menos lo he entendido y las dudas que me han surgido.

Muchas gracias por vuestro tiempo y honestidad. 

Buenos dias.

Siempre he tenido una pregunta curiosa sobre el comando shred....

Como bien sabemos el comando shred, nos permite hacer un borrado seguro desde cualquier distribucion.

Yo acostumbro mucho a utilizar estos parametros

shred -vuz -n 10 <file>

Los parametros son:

• -u: Elimina el archivo una vez sobrescrito
• -z: Sobrescribe el archivo a zeros (supongo que es el que se encarga de convertir los bits 1 a 0)
• -v: Pinta por pantalla el proceso de shred
• -n: Numero de sobrescrituras que hace antes de eliminar el archivo (si esta el -u)

Ok, hasta aquí lo entiendo, pero la pregunta del millon..... ¿Porque tantas pasadas?

Yo lo entiendo así, y es que, el -z convierte los bits 1 a 0, haciendo que este no se pueda recuperar con alguna herramienta foranea (ejemplo: foremost).

Se dice que (o lo he leido/oido) que cuando más pasadas más seguro es y...¿menos posible de recuperar? eso me suena, pero de donde.

En caso de que se pueda recuperar,¿no es imposible auque sea una unica pasada (sobrescrito una iteracion)?

No acabo de entender porque tantas iteraciones...

Es por mera curiosidad...para entender más sobre su funcionamiento auque no he visto ningún sitio que explicara la razon de las iteraciones....

Además la salida que este imprime en pantalla....como lo interpreto??

$ shred -uzv -n 5 2021-12-04-23-07-11.031-VBoxSVC-1990.log
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: pass 1/6 (random)...
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: pass 2/6 (000000)...
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: pass 3/6 (random)...
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: pass 4/6 (ffffff)...
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: pass 5/6 (random)...
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: pass 6/6 (000000)...
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: removing
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: renamed to 0000000000000000000000000000000000000000
shred: 0000000000000000000000000000000000000000: renamed to 000000000000000000000000000000000000000
shred: 000000000000000000000000000000000000000: renamed to 00000000000000000000000000000000000000
shred: 00000000000000000000000000000000000000: renamed to 0000000000000000000000000000000000000
shred: 0000000000000000000000000000000000000: renamed to 000000000000000000000000000000000000
shred: 000000000000000000000000000000000000: renamed to 00000000000000000000000000000000000
shred: 00000000000000000000000000000000000: renamed to 0000000000000000000000000000000000
shred: 0000000000000000000000000000000000: renamed to 000000000000000000000000000000000
shred: 000000000000000000000000000000000: renamed to 00000000000000000000000000000000
shred: 00000000000000000000000000000000: renamed to 0000000000000000000000000000000
shred: 0000000000000000000000000000000: renamed to 000000000000000000000000000000
shred: 000000000000000000000000000000: renamed to 00000000000000000000000000000
shred: 00000000000000000000000000000: renamed to 0000000000000000000000000000
shred: 0000000000000000000000000000: renamed to 000000000000000000000000000
shred: 000000000000000000000000000: renamed to 00000000000000000000000000
shred: 00000000000000000000000000: renamed to 0000000000000000000000000
shred: 0000000000000000000000000: renamed to 000000000000000000000000
shred: 000000000000000000000000: renamed to 00000000000000000000000
shred: 00000000000000000000000: renamed to 0000000000000000000000
shred: 0000000000000000000000: renamed to 000000000000000000000
shred: 000000000000000000000: renamed to 00000000000000000000
shred: 00000000000000000000: renamed to 0000000000000000000
shred: 0000000000000000000: renamed to 000000000000000000
shred: 000000000000000000: renamed to 00000000000000000
shred: 00000000000000000: renamed to 0000000000000000
shred: 0000000000000000: renamed to 000000000000000
shred: 000000000000000: renamed to 00000000000000
shred: 00000000000000: renamed to 0000000000000
shred: 0000000000000: renamed to 000000000000
shred: 000000000000: renamed to 00000000000
shred: 00000000000: renamed to 0000000000
shred: 0000000000: renamed to 000000000
shred: 000000000: renamed to 00000000
shred: 00000000: renamed to 0000000
shred: 0000000: renamed to 000000
shred: 000000: renamed to 00000
shred: 00000: renamed to 0000
shred: 0000: renamed to 000
shred: 000: renamed to 00
shred: 00: renamed to 0
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: removed

Si alguíen me lo puede explicar, para entender....se lo agradeceria.

Gracias de antemano. 

Buenas. Intenta hacer un apt-get install -f a ver si puedes descargar las dependencias. Otra manera seria hacerlo manualmente pero es un tostón, pues es muy tedioso.

Espero haberte ayudado.

Sent from my VTR-L09 using Tapatalk

En realidad, mi pregunta era.... Como matar un proceso zombie cuando el proceso cliente se cierra.








Para solucionar esto lo que hice es.... cuando esta escuchando clientes, además de iniciar un proceso hijo que será el cliente que se quiere conectar, creo un hilo en el proceso padre que estará en escucha de un evento que lo paso como parametro al proceso hijo del cliente.

Y este que se activa al querrer cerrar el cliente, gracias al hilo obtendrá el evento activado y se encargará de unir el proceso hijo del cliente al proceso padre. Después hace un break para acabar el hilo

Y finalmente se cierra el cliente.

Pasos que he hecho:

Primero, cuando escucho a los clientes, añado:

Código (python) [Seleccionar] Expandir


while sockSSL:
    connection, address = sockSSL.accept()
    eventChildStop = multiprocessing.Event()
    subprocess = multiprocessing.Process(target=ClientListener, name="client", args=(connection, address,eventChildStop))

    # This thread is responsible of close the client's child process
    threading.Thread(target=ClientListener.exitSubprocess,name="closeChildProcess",args=(eventChildStop,subprocess,)).start()
    subprocess.start()
    time.sleep(1)


Después in the nuevo metodo de la clase ClientsListener, cambio:

Código (python) [Seleccionar] Expandir


@staticmethod
def handlerEvent(event,childProcesses):
    while True:
        if event.is_set():
            print(childProcesses)
            # terminate child process
            break
        time.sleep(.5)

por

Código (python) [Seleccionar] Expandir


# This method get as argument the process child. For join it at parent process
@staticmethod
def exitSubprocess(event,process):
    while True:
        if event.is_set():
            process.join()
            break
        time.sleep(.5)

cambio el nombre del metodo. No es que, añada otro, sino que cambio el nombre.

en el proceso hijo al cerrar le añado un time.sleep de un 1 segundo para que le de tiempo al hijo a unir el proceso hijo al proceso padre.
En el ultimo finally.

Código (python) [Seleccionar] Expandir


class ClientListener:
    def __init__(self,conn,addr,event):
        try:
            self.conn, self.addr = conn, addr
            self.nick = ""
            self.__listenData()
        except (KeyboardInterrupt,SystemExit) as err:
            print(logFile().message(f"The host {self.nick} ({self.addr[0]}:{self.addr[1]}) left", True, "INFO"))
        except BaseException as err:
            type, object, traceback = sys.exc_info()
            file = traceback.tb_frame.f_code.co_filename
            line = traceback.tb_lineno
            print(logFile().message(f"{err} in {file}:{line}", True, "ERROR"))
        finally:
            try:
                ListClients().remove(self.conn)
                self.conn.close()
            except:
                None
            finally:
                Client(self.conn,self.addr).registre(self.nick,"DISCONNECTED",False)
                event.set()
                # This will delay 1 second to close the proccess, for this gives time at exitSubprocess method to join the client's child process with the parent process
                time.sleep(1)


Muchas gracias por vuestra atención y tiempo