Added file queue handling

lib/threadpool/fileQueue.h

@@ -0,0 +1,224 @@
+#pragma once
+#ifndef _FILE_QUEUE
+#define _FILE_QUEUE
+
+
+// struttura dati per gestire i file in memoria principale
+typedef struct {
+    char *filepath;     // path assoluto del file
+    int O_LOCK;         // 1 se il file e' in modalita' locked
+    int owner;          // client che possiede la lock sul file
+    int open;           // 1 se il file e' aperto
+    void *data;         // contenuto del file
+    size_t size;        // dimensione del file in bytes
+} fileT;
+
+// nodo di una linked list
+typedef struct node {
+    fileT *data;
+    struct node *next;
+} nodeT;
+
+// coda FIFO
+typedef struct {
+    nodeT *head;        // puntatore al primo elemento
+    nodeT *tail;        // puntatore all'ultimo elemento
+    size_t maxLen;      // numero massimo di elementi
+    size_t len;         // numero attuale di elementi
+    size_t maxSize;     // dimensione massima
+    size_t size;        // dimensione attuale
+    pthread_mutex_t m;  // lock sulla coda
+} queueT;
+
+
+
+/**
+ * Creazione di un fileT.
+ * \param f: string che identifica il fileT tramite il suo path assoluto
+ * \param O_LOCK: 1 locked, 0 unlocked
+ * \param client: client associato
+ * \param open: apertura del file dopo la creazione
+ *
+ * \retval puntatore al fileT, NULL se errore (errno)
+ */
+fileT* createFileT(char *f, int O_LOCK, int client, int open);
+
+/**
+ * Append su un fileT.
+ * \param f: fileT sul quale scrivere
+ * \param data: puntatore al buffer da scrivere
+ * \param size: dimensione in bytes del buffer
+ *
+ * \retval 0 se successo, -1 se errore (errno)
+ */
+int writeFileT(fileT *f, void *data, size_t size);
+
+/**
+ * Rimozione di un fileT.
+ * \param f
+ */
+void destroyFile(fileT *f);
+
+
+
+/**
+ * Alloca ed inizializza una coda di fileT. Deve essere chiamata da un solo
+ * thread.
+ * \param maxLen: lunghezza massima della coda
+ * \param maxSize: dimensione massima della coda in bytes
+ *
+ * \retval puntatore alla coda allocata, NULL se errore
+ */
+queueT* createQueue(size_t maxLen, size_t maxSize);
+
+/**
+ * Inserisce un fileT nella coda.
+ * \param q: puntatore alla coda
+ * \param data: puntatore al fileT da inserire
+ *
+ * \retval 0 se successo, -1 se errore (errno)
+ */
+int enqueue(queueT *q, fileT* data);
+
+/**
+ * Estrae un fileT dalla coda.
+ * \param q: puntatore alla coda
+ *
+ * \retval puntatore al file estratto, NULL se errore
+ */
+fileT* dequeue(queueT *q);
+
+/**
+ * Estrae un fileT dalla coda come la dequeue, ma invece di restituire il
+ * file estratto lo distrugge immediatamente, liberandone la memoria.
+ *
+ * \param q: puntatore alla coda
+ */
+void voidDequeue(queueT *q);
+
+/**
+ * Stampa l'intero contenuto della coda.
+ * \param stream: file su cui stampare
+ * \param q: puntatore alla coda da stampare
+ *
+ * \retval 0 se successo, -1 se errore (errno)
+ */
+int printQueue(FILE *stream, queueT *q);
+
+
+
+/**
+ * Cerca di ottenere il lock su un fileT, fallisce se un altro client ha gia'
+ * richiesto la lock
+ * \param q: puntatore alla coda che contiene il fileT
+ * \param filepath: path assoluto (identificatore) del fileT
+ * \param owner: client che ha richiesto l'operazione
+ *
+ * \retval 0 se successo, -1 se errore (errno)
+ */
+int lockFileInQueue(queueT *q, char *filepath, int owner);
+
+/**
+ * Rilascia il lock di un file, fallisce se non si e' il possessore del lock
+ * \param q: puntatore alla coda che contiene il fileT
+ * \param filepath -> path assoluto (identificatore) del fileT
+ * \param owner -> client che ha richiesto l'operazione
+ *
+ * \retval 0 se successo, -1 se errore (errno)
+ */
+int unlockFileInQueue(queueT *q, char *filepath, int owner);
+
+/**
+ * Apre un fileT contenuto nella coda. Fallisce se il lock appartiene a un
+ * client diverso.
+ * \param q: puntatore alla coda che contiene il fileT da aprire
+ * \param filepath: path assoluto (identificatore) del fileT da aprire
+ * \param O_LOCK: 1 locked, 0 unlocked
+ * \param owner: client che ha richiesto l'apertura
+ *
+ * \retval 0 se successo, -1 se errore (errno)
+ */
+int openFileInQueue(queueT *q, char *filepath, int O_LOCK, int owner);
+
+/**
+ * Chiude un file contenuto nella coda. Ha successo se fileT non e' stato aperto.
+ * Fallisce se il file e' stato messo in modalita' locked da un client diverso.
+ * \param q: puntatore alla coda che contiene il fileT da chiudere
+ * \param filepath: path assoluto (identificatore) del fileT da chiudere
+ * \param owner: client che ha richiesto la chiusura
+ *
+ * \retval 0 se successo, -1 se errore (errno)
+ */
+int closeFileInQueue(queueT *q, char *filepath, int owner);
+
+/**
+ * Scrive del contenuto su un fileT all'interno della coda. Fallisce se il file
+ * non e' stato aperto o se il lock appartiene a un client diverso.
+ * \param q: puntatore alla coda che contiene il fileT su cui scrivere
+ * \param filepath: path assoluto (identificatore) del fileT
+ * \param data: buffer che contiene i dati
+ * \param size: dimensione in bytes del buffer
+ * \param owner: client che ha richiesto l'operazione di scrittura
+ *
+ * \retval 0 se successo, -1 se errore (errno)
+ */
+int writeFileInQueue(queueT *q, char *filepath, void *data, size_t size, int owner);
+
+/**
+ * Scrive del contenuto in append su un fileT all'interno della coda. Fallisce
+ * se il file non e' stato aperto o se il lock appartiene a un client diverso.
+ * \param q: puntatore alla coda che contiene il fileT su cui effettuare l'append
+ * \param filepath: path assoluto (identificatore) del fileT
+ * \param data: buffer che contiene i dati
+ * \param size: dimensione in bytes del buffer
+ * \param owner: client che ha richiesto l'operazione di append
+ *
+ * \retval 0 se successo, -1 se errore (setta errno)
+ */
+int appendFileInQueue(queueT *q, char *filepath, void *data, size_t size, int owner);
+
+/**
+ * Rimuove un fileT dalla coda. Fallisce se non si è in possesso della lock o se
+ * la lock e' posseduta da un client diverso.
+ * \param q: puntatore alla coda che contiene il fileT da rimuovere
+ * \param filepath: path assoluto (identificatore) del fileT da rimuovere
+ * \param owner: client che ha richiesto la rimozione
+ *
+ * \retval 0 se successo, -1 se errore (errno)
+ */
+int removeFileFromQueue(queueT *q, char *filepath, int owner);
+
+
+
+/**
+ * Cerca un fileT nella coda.
+ * \param q: puntatore alla coda sulla quale cercare il fileT
+ * \param filepath: path assoluto del fileT da cercare
+ *
+ * \retval puntatore a una copia del fileT se trovato, NULL se non trovato o errore (errno)
+ */
+fileT* find(queueT *q, char *filepath);
+
+/**
+ * Numero di elementi presenti nella coda.
+ * \param q: puntatore alla coda
+ *
+ * \retval numero di elementi presenti, -1 se errore (errno)
+ */
+size_t getLen(queueT *q);
+
+/**
+ * Restituisce la dimensione attuale della coda in bytes.
+ * \param q: puntatore alla coda
+ *
+ * \retval dimensione della coda in bytes, -1 se errore (errno)
+ */
+size_t getSize(queueT *q);
+
+/**
+ * Cancella una coda allocata con createQueue e ne libera la memoria.
+ * \param q: puntatore alla coda da distruggere
+ */
+void destroyQueue(queueT *q);
+
+#endif // _FILE_QUEUE