Buenos dias!
Ya esta resuelto. Puede que no sea la mejor opcion, ni la más adecuada, pero me veo obligado ha hacerlo así pues Windows tiende a matar los procesos.

Así como lo queria hacer tendría que funcionar para mis ojos, pero la realidad es que no, y no se porque (en Linux funcionaria....).

Lo que hice es añadir el HandlerSignals() justo despues de crear el socket (dentro del __createSocket, despues del listen)

main.py:

#!/usr/bin/python3
import sys,socket,urllib3,time,multiprocessing, threading
from sources.ClientListener import ClientListener
from sources.handlerSignals import HandlerSignals
from sources.utils import logFile, Hosts, getIpAddress, Notify
from sources.Server import Server
from sources.Requests import Requests
 
class SocketServer:
    def __init__(self,**kwargs):
        try:
            # [...]
            self.__createSocket()
 
        # When the service shutdown successfully
        except (KeyboardInterrupt, SystemExit,GeneratorExit) as err:
                None
 
        finally:
            try:
                self.sock.close()
            except:
                None
            Notify("Turnning off ClassAdminS",logFile().message("Good Bye. What you have a good day :)", True, "INFO"))
 
    def __createSocket(self):
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.bind(("",self.PORT))
        self.sock.listen(self.CLIENTS)
        HandlerSignals(self.sock)
        Notify("Start ClassAdminS",logFile().message(f"Good days :D. I am listenning {self.CLIENTS} clients by port {self.PORT}.",True,"INFO"))
        self.__handlerClients()
 
if __name__=="__main__":
    SocketServer(args=sys.argv)
 

La diferencia es que la funcion HnadlerSignals(sock) coge como parametro la variable que contiene el objecto socket.

handlerSignals.py

import signal, platform
class HandlerSignals:
    def __init__(self,sock):
        self.sock = sock
        signal.signal(signal.SIGTERM,self.shutdown)
        # shutdown signal in Windows
        if platform.system().upper()=="WINDOWS":
            import win32api
            win32api.SetConsoleCtrlHandler(self.shutdownWin, True)
 
    def shutdownWin(self,a):
        self.sock.close()
 
    def shutdown(self,code,msg):
        raise SystemExit
 

La gran diferencia de handlerSignals.py con el anterior es que, al hacer Ctrl+C y llamar a la funcion shutdownWin(), este cierra el socket y me muestra el Notify de el try/except/finally del main.py.

Así me funciona correctamente, aunque no se si es muy buena practica,pero me funciona.

Hay que tener en cuenta que el HandlerSignals() debe estar justo después de la declaración de la variable self.sock. Yo lo pongo despues del self.sock.listen().

https://imgur.com/gallery/B2VR7Lp

Por dos cosas:

• Pues para salir limpiamente y correctamente
• Pues este script lo ejecuto como servicio con NSSM

NSSM al parar un servicio, implicitamente hace un Ctrl+C y espera una reaccion. Si no hay reaccion este se cierra forzosamente y muestra el siguiente mensaje.
https://imgur.com/gallery/n5UO4sL

Ahora si el script detecta el Ctrl+C en CMD....
https://imgur.com/gallery/qLnBGOi

En el NSSM este es configurado así
https://imgur.com/gallery/ZEwvmOq

Gracias por vuestra atencion!

Buenas,
Feliz año 

Estoy con un socket servidor que al estar corriendo quiero que si el usuario hace Ctrl+C en el CMD este sale limpiamente (con un SIGINT).

main.py

from sources.handlerSignals import HandlerSignals
class SocketServer:
    def __init__(self,**kwargs):
        try:
            HandlerSignals()
            # [...]
 
        # When the service shutdown successfully
        except (KeyboardInterrupt, SystemExit,GeneratorExit) as err:
            print("KeyboardInterrupt")
            None
 
        finally:
            try:
                self.sock.close()
            except:
                None
            print("Turnning off ClassAdminS")
            sys.exit(0)
 
    # continue code
if __name__=="__main__":
    SocketServer(args=sys.argv)
 

El HandlerSignals() esta en una carpeta 'sources' en el archivo handlerSignals
  -main.py
  |
  - sources/
      \-- handlerSignals.py


handlerSignals.py

import signal, sys, platform
class HandlerSignals:
    def __init__(self):
        signal.signal(signal.SIGTERM,self.shutdown)
 
        # shutdown signal in Windows
        if platform.system().upper()=="WINDOWS":
            import win32api
            win32api.SetConsoleCtrlHandler(self.shutdownWin, True)
 
    def shutdownWin(self,a):
        print("Ctrl+c")
        raise SystemExit
 
    def shutdown(self,code,msg):
        raise SystemExit
 

Como se puede ver si el sistema es Windows, se ejecuta Que esta en escucha de Ctrl+C en windows CMD. Así que al ser presionado se llama a la funcion shutdownWin que este imprime "Ctrl+C" y lanza una excepcion SystemExit.

Que esta excepcion teoricamente es recogida por main.py que y sale de la terminal.

Pero no ocurre eso. Al lanzarse el SystemExit no imprime "KeyboardInterrupt". Y no se porque pasa....


https://imgur.com/gallery/x5jxQhM

Parece como si la excepcion no se pueda pasar al main.py

Como lo puedo solucionar...? Gracias por vuestra atencion.

Buenas!! Feliz año!

Y si llamas a mostrarCliente() en el finally de la funcion crearCliente(). Y en el mostrarCliente() reutilizas la variable cur.

import pymysql
 
con = pymysql.connect(host='sql11.freemysqlhosting.net',
                             user='sql11459959',
                             password='kcF1ibf3Me',
                             database='sql11459959',
                             charset='utf8mb4',
                             cursorclass=pymysql.cursors.DictCursor)
 
def crearCliente():
    try:
        cur = con.cursor()
        crearCliente = "INSERT INTO test1(name,email) VALUES ('prueba', 'prueba')"
        cur.execute(crearCliente) 
        con.commit()
 
        #con.close()
 
        print("Se guardo correctamente")
    except:
        print ("Error")
 
    finally:
        try:
            mostrarCliente(con,cur)
        except:
            None
 
 
def mostrarCliente(con,cur):
    try:
        mostrarCliente = "SELECT * FROM test1 WHERE id = 19"
        cur.execute(mostrarCliente)
        rows = cur.fetchall()
        print("El cliente es:", rows)
    except:
        print("Error2")
 
    finally:
        try:
            con.close()
        except:
            None
 
 
 
 
crearCliente()
print ("Se ha guardado")
 

No he probado el codigo...

Epero haberte ayudado )

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í

   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

import pymysql
 

Si no lo tienes instalado, lo puedes instalar haceindo

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

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()

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í

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

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!

Buenos dias.
¿Porque falla y como solucionarlo?

# 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....

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.

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.

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.

Entiendo ok, muchas gracias a los dos.

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

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... 

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

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)

Si yo solo le hago una pasada, en un archivo que contiene 700K
y al ejecutar shred -z -n 0, este me sobrescribiria el fichero a
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....

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.

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






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


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í?


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.