update db and fix remains

Author: anhduckkzz

Assignment1/client.py

@@ -77,10 +77,10 @@ def _handle_peer(self, peer_socket, peer_address):
             peer_socket.close()
             logging.info(f"[{thread_name}] Closed connection with peer {peer_address}")
 
-    def _do_publish(self, lname, fname):
+    def _do_publish(self, lname, fname, allow_overwrite=False):
         if not os.path.exists(lname):
             logging.error(f"File {lname} does not exist.")
-            return
+            raise FileNotFoundError(f"File {lname} does not exist.")
         file_size = os.path.getsize(lname)
         last_modified = datetime.utcfromtimestamp(os.path.getmtime(lname)).isoformat() + "Z"
         source_ext = os.path.splitext(lname)[1]
@@ -93,12 +93,17 @@ def _do_publish(self, lname, fname):
             'fname': fname,
             'file_size': file_size,
             'last_modified': last_modified,
+            'allow_overwrite': allow_overwrite,
         }
-        if protocol.send_message(self.server_socket, publish_message):
-            response = protocol.receive_message(self.server_socket)
-            logging.info(f"Publish response: {response}")
-        else:
+        if not protocol.send_message(self.server_socket, publish_message):
             logging.error("Failed to send publish message.")
+            raise RuntimeError("Failed to send publish message.")
+        response = protocol.receive_message(self.server_socket)
+        if response is None:
+            logging.error("No publish response received from server.")
+            raise RuntimeError("No response received after publish request.")
+        logging.info(f"Publish response: {response}")
+        return response
 
     def _download_from_peer(self, chosen_peer, fname_to_save):
         logging.info("Starting download from peer...")

Assignment1/client_ui.py

@@ -117,11 +117,11 @@ def disconnect(self):
 
         logging.info("Client disconnected.")
 
-    def publish(self, local_path, alias):
+    def publish(self, local_path, alias, allow_overwrite=False):
         if not self.connected or not self.client:
             raise RuntimeError("Client is not connected.")
         with self._socket_lock:
-            self.client._do_publish(local_path, alias)
+            return self.client._do_publish(local_path, alias, allow_overwrite=allow_overwrite)
 
     def fetch_peer_list(self, fname):
         if not self.connected or not self.client:
@@ -412,18 +412,70 @@ def publish_file(self):
 
         threading.Thread(
             target=self._publish_task,
-            args=(local_path, alias),
+            args=(local_path, alias, False),
             daemon=True,
         ).start()
 
-    def _publish_task(self, local_path, alias):
+    def _publish_task(self, local_path, alias, allow_overwrite):
         try:
-            self.controller.publish(local_path, alias)
+            response = self.controller.publish(local_path, alias, allow_overwrite=allow_overwrite)
         except Exception as exc:
             logging.error("Publish failed: %s", exc)
             self.root.after(0, lambda: messagebox.showerror("Publish error", str(exc)))
             return
-        logging.info("Publish request sent for %s -> alias '%s'", local_path, alias)
+        logging.info(
+            "Publish response received for %s -> alias '%s': %s",
+            local_path,
+            alias,
+            response,
+        )
+        self.root.after(
+            0,
+            lambda: self._handle_publish_response(local_path, alias, response, allow_overwrite),
+        )
+
+    def _handle_publish_response(self, local_path, alias, response, allow_overwrite):
+        status = (response or {}).get("status")
+        message = response.get("message") if isinstance(response, dict) else None
+        if not isinstance(response, dict):
+            messagebox.showerror("Publish error", "Unexpected response from server.")
+            return
+
+        if status == "conflict" and not allow_overwrite:
+            existing_path = response.get("existing_lname") or "unknown location"
+            prompt = (
+                "Alias '{alias}' is already published for this client.\n\n"
+                "Existing path: {existing}\n"
+                "New path: {new}\n\n"
+                "Do you want to overwrite the previous file entry?"
+            ).format(alias=alias, existing=existing_path, new=local_path)
+            overwrite = messagebox.askyesno("Overwrite alias?", prompt)
+            if overwrite:
+                logging.info("User confirmed overwrite for alias '%s'.", alias)
+                threading.Thread(
+                    target=self._publish_task,
+                    args=(local_path, alias, True),
+                    daemon=True,
+                ).start()
+            else:
+                logging.info("User declined to overwrite alias '%s'.", alias)
+                messagebox.showinfo("Publish", f"Publish cancelled for alias '{alias}'.")
+            return
+
+        if status in ("created", "updated"):
+            title = "Publish" if status == "created" else "Publish Updated"
+            messagebox.showinfo(title, message or f"Alias '{alias}' published successfully.")
+            return
+
+        if status == "unchanged":
+            messagebox.showinfo("Publish", message or f"Alias '{alias}' is already up to date.")
+            return
+
+        if status == "error":
+            messagebox.showerror("Publish error", message or f"Failed to publish '{alias}'.")
+            return
+
+        messagebox.showinfo("Publish", message or f"Alias '{alias}' publish result: {status}")
 
     def fetch_file(self):
         fname = self.fetch_name_var.get().strip()
@@ -537,11 +589,11 @@ def _show_peer_selection(self, fname, peer_list):
         listbox.pack(padx=10, pady=5, fill=tk.BOTH, expand=True)
 
         for idx, peer in enumerate(peer_list, start=1):
-            hostname = peer.get("hostname") or "Unknown"
-            original_name = os.path.basename(peer.get("lname") or fname)
+            client_label = peer.get("hostname") or peer.get("ip") or "Unknown client"
+            size_label = self._format_file_size(peer.get("file_size"))
             listbox.insert(
                 tk.END,
-                f"{idx}. {hostname} ({original_name})",
+                f"{idx}. {client_label} ({size_label})",
             )
 
         button_frame = tk.Frame(dialog)
@@ -600,7 +652,7 @@ def on_cancel():
         all_button = tk.Button(button_frame, text="Download All", command=on_select_all, bg=PASTEL_BUTTON)
         all_button.grid(row=0, column=1, padx=5, sticky="ew")
 
-        custom_button = tk.Button(button_frame, text="Custom...", command=on_custom, bg=PASTEL_BUTTON)
+        custom_button = tk.Button(button_frame, text="Custom", command=on_custom, bg=PASTEL_BUTTON)
         custom_button.grid(row=0, column=2, padx=5, sticky="ew")
 
         cancel_button = tk.Button(button_frame, text="Cancel", command=on_cancel, bg=PASTEL_BUTTON)
@@ -668,6 +720,20 @@ def _on_multi_download_finished(self, successes, failures):
         messagebox.showinfo("Fetch summary", summary)
         self.fetch_button.config(state=tk.NORMAL)
 
+    def _format_file_size(self, size_value):
+        try:
+            size = int(size_value)
+        except (TypeError, ValueError):
+            return "unknown size"
+        units = ["B", "KB", "MB", "GB", "TB"]
+        for unit in units:
+            if size < 1024 or unit == "TB":
+                if unit == "B":
+                    return f"{size} {unit}"
+                return f"{size:.1f} {unit}"
+            size /= 1024
+        return f"{size:.1f} TB"
+
     def _get_preferred_filename(self, peer_info, fallback_name):
         original = peer_info.get("lname")
         if original:

Assignment1/database.py

@@ -54,12 +54,14 @@ def _ensure_schema(self) -> None:
                 last_modified TEXT
             );
         """
+        drop_legacy_index_stmt = "DROP INDEX IF EXISTS uq_file_index_unique_peer;"
         create_index_stmt = """
-            CREATE UNIQUE INDEX IF NOT EXISTS uq_file_index_unique_peer
-                ON file_index (fname, hostname, ip, port, file_size, last_modified);
+            CREATE UNIQUE INDEX IF NOT EXISTS uq_file_index_alias_per_peer
+                ON file_index (fname, hostname, ip, port);
         """
         with self._connect() as conn, conn.cursor() as cur:
             cur.execute(create_table_stmt)
+            cur.execute(drop_legacy_index_stmt)
             cur.execute(create_index_stmt)
         logging.info("Database schema verified.")
 
@@ -85,18 +87,36 @@ def list_peers_for_file(self, fname: str) -> List[Dict[str, object]]:
             rows = cur.fetchall()
         return list(rows)
 
-    def register_file(self, entry: Dict[str, object]) -> bool:
+    def get_entry(self, fname: str, hostname: str, ip: str, port: int) -> Optional[Dict[str, object]]:
+        query = """
+            SELECT fname, hostname, ip, port, lname, file_size, last_modified
+            FROM file_index
+            WHERE fname = %s AND hostname = %s AND ip = %s AND port = %s
+            LIMIT 1
+        """
+        with self._connect() as conn, conn.cursor(cursor_factory=RealDictCursor) as cur:
+            cur.execute(query, (fname, hostname, ip, port))
+            row = cur.fetchone()
+        return dict(row) if row else None
+
+    def register_file(self, entry: Dict[str, object]) -> str:
         insert_stmt = """
             INSERT INTO file_index (fname, hostname, ip, port, lname, file_size, last_modified)
             VALUES (%(fname)s, %(hostname)s, %(ip)s, %(port)s, %(lname)s, %(file_size)s, %(last_modified)s)
-            ON CONFLICT (fname, hostname, ip, port, file_size, last_modified)
-            DO NOTHING
-            RETURNING id
+            ON CONFLICT (fname, hostname, ip, port)
+            DO UPDATE SET
+                lname = EXCLUDED.lname,
+                file_size = EXCLUDED.file_size,
+                last_modified = EXCLUDED.last_modified
+            RETURNING id, xmax = 0 AS inserted
         """
         with self._connect() as conn, conn.cursor() as cur:
             cur.execute(insert_stmt, entry)
-            inserted = cur.fetchone()
-        return inserted is not None
+            result = cur.fetchone()
+        if not result:
+            return "none"
+        _, inserted = result
+        return "inserted" if inserted else "updated"
 
     def delete_entries_for_peer(self, hostname: str, ip: str, port: int) -> Dict[str, int]:
         delete_stmt = """

Assignment1/server.py

@@ -70,6 +70,7 @@ def handle_client(self, client_socket: socket.socket, client_address: tuple[str,
                 if action == "publish":
                     lname = message.get("lname")
                     fname = message.get("fname")
+                    allow_overwrite = bool(message.get("allow_overwrite"))
                     if not lname or not fname:
                         response = {"status": "error", "message": "Missing lname or fname"}
                     else:
@@ -82,15 +83,60 @@ def handle_client(self, client_socket: socket.socket, client_address: tuple[str,
                             "last_modified": message.get("last_modified"),
                             "fname": fname,
                         }
-                        inserted = self.db.register_file(peer_info)
-                        if inserted:
-                            logging.info("[%s] Client %s publishing file %s", thread_name, client_address, fname)
-                            response = {"status": "success", "message": f"File {fname} published successfully"}
-                        else:
-                            logging.warning(
-                                "[%s] File '%s' already published with same metadata by %s", thread_name, fname, client_address
+                        existing_entry = None
+                        if client_hostname and client_ip and client_p2p_port:
+                            existing_entry = self.db.get_entry(fname, client_hostname, client_ip, client_p2p_port)
+
+                        if existing_entry:
+                            same_file_path = existing_entry.get("lname") == lname
+                            metadata_matches = (
+                                same_file_path
+                                and existing_entry.get("file_size") == peer_info["file_size"]
+                                and existing_entry.get("last_modified") == peer_info["last_modified"]
                             )
-                            response = {"status": "exists", "message": f"File {fname} already registered with same metadata"}
+                            if metadata_matches:
+                                logging.info(
+                                    "[%s] Client %s attempted to republish %s with unchanged metadata",
+                                    thread_name,
+                                    client_address,
+                                    fname,
+                                )
+                                response = {
+                                    "status": "unchanged",
+                                    "message": f"File {fname} is already up to date for this client.",
+                                }
+                            elif not same_file_path and not allow_overwrite:
+                                logging.info(
+                                    "[%s] Client %s publish conflict on alias %s (existing path %s, new path %s)",
+                                    thread_name,
+                                    client_address,
+                                    fname,
+                                    existing_entry.get("lname"),
+                                    lname,
+                                )
+                                response = {
+                                    "status": "conflict",
+                                    "message": f"Alias '{fname}' is already published for this client.",
+                                    "existing_lname": existing_entry.get("lname"),
+                                }
+                            else:
+                                result = self.db.register_file(peer_info)
+                                logging.info(
+                                    "[%s] Client %s overwrote alias %s with path %s",
+                                    thread_name,
+                                    client_address,
+                                    fname,
+                                    lname,
+                                )
+                                response = {
+                                    "status": "updated",
+                                    "message": f"File {fname} metadata updated.",
+                                    "result": result,
+                                }
+                        else:
+                            result = self.db.register_file(peer_info)
+                            logging.info("[%s] Client %s publishing new file %s", thread_name, client_address, fname)
+                            response = {"status": "created", "message": f"File {fname} published successfully", "result": result}
                     protocol.send_message(client_socket, response)
 
                 elif action == "fetch":