mirror of
https://github.com/KeksPirates/SoftwareManager.git
synced 2026-08-04 09:59:41 +02:00
Vxrtrauter
cc51f57e18
Improve thread-safety, logging, and various bug fixes across the app. Key changes: - Add and use state.downloads_lock around accesses to state.active_downloads in multiple modules (UI, libtorrent, misc, direct downloads) to prevent race conditions. - Prevent concurrent dl_status_loop runs using a non-blocking _loop_lock and ensure proper iteration over a snapshot of downloads. - Add metadata timeout when waiting for torrent metadata and fix free-space check logic to remove or reject downloads appropriately. - Refactor download log persistence: add _load_downloads and _save_downloads helpers and centralize JSON read/write logic in utils/logging/logs.py. - Optimize DirectDownloadStatus speed window by switching to deque and using popleft to trim older samples. - Trim console log widget to 500 lines to avoid unbounded growth. - Add small state fields for custom image positioning (x/y and enabled flag). - Fix Steamrip scraper caching behavior and make Uztracker return an empty list on fetch failures. - Add defensive checks in run_download to handle missing links. These changes focus on stability and correctness for concurrent download handling and durable logging.
230 lines
7.3 KiB
Python
230 lines
7.3 KiB
Python
from network.interface import get_interface_ip
|
|
from utils.general.wrappers import run_thread
|
|
from utils.logging.logs import consoleLog
|
|
from utils.data.state import state
|
|
import libtorrent as lt
|
|
import threading
|
|
import platform
|
|
import ctypes
|
|
import time
|
|
import os
|
|
|
|
|
|
_loop_lock = threading.Lock()
|
|
|
|
def get_free_space_mb(dirname):
|
|
if platform.system() == 'Windows':
|
|
free_bytes = ctypes.c_ulonglong(0)
|
|
ctypes.windll.kernel32.GetDiskFreeSpaceExW(ctypes.c_wchar_p(dirname), None, None, ctypes.pointer(free_bytes))
|
|
return free_bytes.value
|
|
else:
|
|
st = os.statvfs(dirname)
|
|
return st.f_bavail * st.f_frsize
|
|
|
|
def check_space():
|
|
while not state.shutdown_event.is_set():
|
|
with state.downloads_lock:
|
|
items = list(state.active_downloads.items())
|
|
for _, magnetdl in items:
|
|
try:
|
|
status = magnetdl.status()
|
|
except RuntimeError:
|
|
continue
|
|
|
|
if status.state == lt.torrent_status.downloading:
|
|
free_space = get_free_space_mb(state.download_path)
|
|
total_size = status.total_wanted
|
|
|
|
if free_space < total_size:
|
|
consoleLog(f"Not enough free space to continue downloading: {status.name}")
|
|
magnetdl.pause()
|
|
break
|
|
|
|
time.sleep(5)
|
|
|
|
def init_session():
|
|
if state.dl_session is not None:
|
|
return
|
|
|
|
state.dl_session = lt.session()
|
|
|
|
|
|
settings = {
|
|
"upload_rate_limit": state.up_speed_limit * 1024,
|
|
"download_rate_limit": state.down_speed_limit * 1024,
|
|
"enable_dht": True,
|
|
"enable_lsd": True,
|
|
"enable_upnp": True,
|
|
"enable_natpmp": True,
|
|
"dht_bootstrap_nodes": "router.bittorrent.com:6881,dht.transmissionbt.com:6881",
|
|
"connections_limit": state.max_connections,
|
|
"active_downloads": state.max_downloads
|
|
}
|
|
|
|
if state.bound_interface:
|
|
interface_ip = get_interface_ip(state.bound_interface)
|
|
if interface_ip:
|
|
settings["outgoing_interfaces"] = interface_ip
|
|
settings["listen_interfaces"] = f"{interface_ip}:6881"
|
|
consoleLog(f"Binding to Interface IP: {interface_ip}")
|
|
else:
|
|
consoleLog(f"Skipping Binding, no Interface set. ({state.bound_interface})")
|
|
|
|
state.dl_session.apply_settings(settings)
|
|
|
|
consoleLog("Initialized Session")
|
|
|
|
|
|
def add_download(magnet_uri):
|
|
|
|
if state.active_downloads is None:
|
|
state.active_downloads = {}
|
|
|
|
init_session()
|
|
free_space = get_free_space_mb(state.download_path)
|
|
|
|
with state.downloads_lock:
|
|
already_active = magnet_uri in state.active_downloads
|
|
handle = state.active_downloads.get(magnet_uri) if already_active else None
|
|
if already_active:
|
|
try:
|
|
status = handle.status()
|
|
|
|
if status.has_metadata:
|
|
filepath = os.path.join(status.save_path, status.name)
|
|
|
|
if not os.path.exists(filepath):
|
|
|
|
consoleLog(f"File Deleted, redownloading: {status.name}")
|
|
state.dl_session.remove_torrent(handle)
|
|
with state.downloads_lock:
|
|
del state.active_downloads[magnet_uri]
|
|
else:
|
|
consoleLog("Skipping Downloading, download already running...")
|
|
return False
|
|
else:
|
|
consoleLog("Skipping Downloading, download already running... ")
|
|
return False
|
|
except RuntimeError as e:
|
|
consoleLog(f"Error in LibTorrent Handle: {e}")
|
|
with state.downloads_lock:
|
|
del state.active_downloads[magnet_uri]
|
|
|
|
try:
|
|
params = lt.parse_magnet_uri(magnet_uri)
|
|
params.save_path = state.download_path
|
|
|
|
handle = state.dl_session.add_torrent(params)
|
|
metadata_timeout = 60
|
|
metadata_start = time.time()
|
|
while not handle.has_metadata():
|
|
if time.time() - metadata_start > metadata_timeout:
|
|
state.dl_session.remove_torrent(handle)
|
|
consoleLog("Timed out waiting for torrent metadata")
|
|
return False
|
|
time.sleep(1)
|
|
|
|
total_size = handle.get_torrent_info().total_size()
|
|
|
|
if free_space <= total_size:
|
|
state.dl_session.remove_torrent(handle)
|
|
consoleLog("Not enough free space to download this item.")
|
|
return False
|
|
|
|
except Exception as e:
|
|
consoleLog(f"Failed to add torrent or fetch info: {e}")
|
|
return False
|
|
if handle:
|
|
with state.downloads_lock:
|
|
state.active_downloads[magnet_uri] = handle
|
|
consoleLog(f"Added {magnet_uri} to downloads")
|
|
|
|
run_thread(threading.Thread(target=dl_status_loop))
|
|
return True
|
|
|
|
|
|
def add_seed(magnet_uri, file_path):
|
|
if state.active_downloads is None:
|
|
state.active_downloads = {}
|
|
|
|
init_session()
|
|
|
|
with state.downloads_lock:
|
|
if magnet_uri in state.active_downloads:
|
|
consoleLog("Already seeding this torrent")
|
|
return False
|
|
|
|
try:
|
|
magnetdl = lt.parse_magnet_uri(magnet_uri)
|
|
magnetdl.save_path = os.path.dirname(file_path)
|
|
handle = state.dl_session.add_torrent(magnetdl)
|
|
except Exception as e:
|
|
consoleLog(f"Failed to add seed: {e}")
|
|
return False
|
|
with state.downloads_lock:
|
|
state.active_downloads[magnet_uri] = handle
|
|
state.seeded_magnets.add(magnet_uri)
|
|
return True
|
|
|
|
|
|
def dl_status_loop():
|
|
if not _loop_lock.acquire(blocking=False):
|
|
return
|
|
|
|
try:
|
|
completed_set = set()
|
|
|
|
if not state.active_downloads:
|
|
consoleLog("No active downloads")
|
|
return
|
|
|
|
while state.active_downloads and not state.shutdown_event.is_set():
|
|
with state.downloads_lock:
|
|
items = list(state.active_downloads.items())
|
|
for magnet_uri, magnetdl in items:
|
|
try:
|
|
status = magnetdl.status()
|
|
except RuntimeError:
|
|
continue
|
|
|
|
if status.state == lt.torrent_status.seeding and magnet_uri not in completed_set:
|
|
consoleLog(f"Download completed: {status.name}")
|
|
|
|
completed_set.add(magnet_uri)
|
|
|
|
if not state.active_downloads:
|
|
break
|
|
|
|
time.sleep(1)
|
|
finally:
|
|
_loop_lock.release()
|
|
|
|
def update_settings():
|
|
|
|
if state.dl_session is None:
|
|
return
|
|
|
|
settings = {
|
|
"upload_rate_limit": state.up_speed_limit * 1024,
|
|
"download_rate_limit": state.down_speed_limit * 1024,
|
|
"connections_limit": state.max_connections,
|
|
"active_downloads": state.max_downloads
|
|
}
|
|
|
|
if state.bound_interface:
|
|
interface_ip = get_interface_ip(state.bound_interface)
|
|
if interface_ip:
|
|
settings["outgoing_interfaces"] = interface_ip
|
|
settings["listen_interfaces"] = f"{interface_ip}:6881"
|
|
consoleLog(f"Binding to Interface IP: {interface_ip}")
|
|
else:
|
|
consoleLog(f"Skipping Binding, no Interface set. ({state.bound_interface})")
|
|
|
|
state.dl_session.apply_settings(settings)
|
|
|
|
def update_bound_interface():
|
|
|
|
settings = { "outgoing_interfaces": state.bound_interface }
|
|
|
|
state.dl_session.apply_settings(settings)
|