Progetto di un bilanciatore applicativo documentale

import sqlite3
import base64
import requests
import os
from requests.exceptions import RequestException, HTTPError, Timeout, ConnectionError

class Coda:
    def __init__(self):
        
        self.db_path = '../ProgettoBilanciatore/bilanciatore.db'
        
        self.setup_database()
        
        self.db_connection = sqlite3.connect(self.db_path)
         
        

    def insert_queue(self, doc, pref_server,stato):
        try:
            cursor = self.db_connection.cursor()
            cursor.execute("INSERT INTO queue (document_id, server, doc_size, status,attempts) VALUES (?, ?,?,?,?)", (str(doc.documentID), pref_server, doc.getSize(),stato,1))
            self.db_connection.commit()
            
            return True
        except Exception as e:
            print(f"Errore durante l'inserimento in coda: {e}")
            self.close() 
            return False

    def update_queue(self, doc,pref_server,statopre, statoseg):
        try:
            cursor = self.db_connection.cursor()
            cursor.execute("UPDATE queue set status = ? WHERE document_id = ? and server = ? and status = ?", (str(statoseg),str(doc.documentID),str(pref_server), str(statopre)))
            self.db_connection.commit()
            
            return True
        except Exception as e:
            print(f"Errore durante la cancellazione dalla coda: {e}")
            self.close() 
            return False
        
    def getDoc_Size(self,segnaposto_stati,stato,elemento):    
        print('Sono interno metodo GetDoc_Size')
        try:        
            cursor = self.db_connection.cursor()  
            # Prepara la query SQL
            query = f"SELECT SUM(doc_size), server FROM queue WHERE status IN ({str(segnaposto_stati)}) AND server = ?"
            
            # Aggiungi il nome del server alla lista dei parametri
            parametri = stato + [elemento]
            print(parametri)
            cursor.execute(query, parametri)
            return cursor.fetchone()
            
        except Exception as e:
            print(f"Errore durante la somma dei documenti")
            self.close()  
            return None,None
                
    
    def delete_queue(self, doc, pref_server,stato):
        try:
            cursor = self.db_connection.cursor()
            cursor.execute("DELETE FROM queue WHERE document_id = ? and server = ? and status = ?", (str(doc.documentID),str(pref_server), str(stato)))
            self.db_connection.commit()
            
            return True
        except Exception as e:
            print(f"Errore durante la cancellazione dalla coda: {e}")
            self.db_connection.close()  
            return False

    def setup_database(self):
        """ Imposta il database creando il file e la tabella se non esistono. """
        db_exists = os.path.exists(self.db_path)
        #db_exists = False
        conn = sqlite3.connect(self.db_path)
        if not db_exists:
            try:
                conn.execute('''CREATE TABLE queue (
                                    document_id INTEGER PRIMARY KEY,
                                    server TEXT NOT NULL,
                                    doc_size INTEGER NOT NULL,
                                    status TEXT NOT NULL
                                );''')
                print("Database e tabella 'queue' creati con successo.")
            except sqlite3.Error as e:
                print(f"Errore nella creazione del database: {e}")
        conn.close()
    def close(self):
        self.db_connection.close()