Add project and deployment instruction (docs/DEPLOYMENT.md)
Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
ars
448
worker/nextcloud_sync.py
Executable file
448
worker/nextcloud_sync.py
Executable file
@@ -0,0 +1,448 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Воркер синхронизации Nextcloud -> Qdrant через Open WebUI API
|
||||
Background процесс для автоматической синхронизации документов
|
||||
"""
|
||||
import sys
|
||||
import time
|
||||
import logging
|
||||
import sqlite3
|
||||
import hashlib
|
||||
from pathlib import Path
|
||||
from typing import Dict, Optional, List
|
||||
from datetime import datetime
|
||||
|
||||
# Импорт локальных модулей
|
||||
from config import load_config, WorkerConfig
|
||||
from nextcloud_client import NextcloudClient
|
||||
from openwebui_client import OpenWebUIClient
|
||||
from document_processor import DocumentProcessor
|
||||
|
||||
# Настройка логирования
|
||||
logging.basicConfig(
|
||||
level=logging.INFO,
|
||||
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
|
||||
handlers=[
|
||||
logging.FileHandler('sync.log'),
|
||||
logging.StreamHandler(sys.stdout)
|
||||
]
|
||||
)
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class SyncStateDB:
|
||||
"""Управление состоянием синхронизации через SQLite"""
|
||||
|
||||
def __init__(self, db_path: str):
|
||||
"""
|
||||
Инициализация БД состояния
|
||||
|
||||
Args:
|
||||
db_path: Путь к файлу БД
|
||||
"""
|
||||
self.db_path = db_path
|
||||
self._init_db()
|
||||
|
||||
def _init_db(self):
|
||||
"""Инициализация схемы БД"""
|
||||
conn = sqlite3.connect(self.db_path)
|
||||
cursor = conn.cursor()
|
||||
|
||||
cursor.execute("""
|
||||
CREATE TABLE IF NOT EXISTS synced_files (
|
||||
file_path TEXT PRIMARY KEY,
|
||||
file_hash TEXT NOT NULL,
|
||||
file_size INTEGER NOT NULL,
|
||||
last_modified TEXT,
|
||||
synced_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
||||
user_id TEXT,
|
||||
document_id TEXT
|
||||
)
|
||||
""")
|
||||
|
||||
cursor.execute("""
|
||||
CREATE INDEX IF NOT EXISTS idx_file_hash ON synced_files(file_hash)
|
||||
""")
|
||||
|
||||
conn.commit()
|
||||
conn.close()
|
||||
|
||||
def get_file_hash(self, file_path: str, file_content: bytes) -> str:
|
||||
"""Вычисление хеша файла"""
|
||||
return hashlib.sha256(file_content).hexdigest()
|
||||
|
||||
def is_file_synced(self, file_path: str, file_hash: str) -> bool:
|
||||
"""
|
||||
Проверка, синхронизирован ли файл
|
||||
|
||||
Args:
|
||||
file_path: Путь к файлу
|
||||
file_hash: Хеш содержимого файла
|
||||
|
||||
Returns:
|
||||
True если файл уже синхронизирован с таким хешем
|
||||
"""
|
||||
conn = sqlite3.connect(self.db_path)
|
||||
cursor = conn.cursor()
|
||||
|
||||
cursor.execute("""
|
||||
SELECT file_hash FROM synced_files
|
||||
WHERE file_path = ? AND file_hash = ?
|
||||
""", (file_path, file_hash))
|
||||
|
||||
result = cursor.fetchone()
|
||||
conn.close()
|
||||
|
||||
return result is not None
|
||||
|
||||
def mark_file_synced(
|
||||
self,
|
||||
file_path: str,
|
||||
file_hash: str,
|
||||
file_size: int,
|
||||
last_modified: Optional[str],
|
||||
user_id: Optional[str],
|
||||
document_id: Optional[str]
|
||||
):
|
||||
"""Отметка файла как синхронизированного"""
|
||||
conn = sqlite3.connect(self.db_path)
|
||||
cursor = conn.cursor()
|
||||
|
||||
cursor.execute("""
|
||||
INSERT OR REPLACE INTO synced_files
|
||||
(file_path, file_hash, file_size, last_modified, synced_at, user_id, document_id)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?)
|
||||
""", (
|
||||
file_path,
|
||||
file_hash,
|
||||
file_size,
|
||||
last_modified,
|
||||
datetime.now().isoformat(),
|
||||
user_id,
|
||||
document_id
|
||||
))
|
||||
|
||||
conn.commit()
|
||||
conn.close()
|
||||
|
||||
def get_sync_stats(self) -> Dict:
|
||||
"""Получение статистики синхронизации"""
|
||||
conn = sqlite3.connect(self.db_path)
|
||||
cursor = conn.cursor()
|
||||
|
||||
cursor.execute("SELECT COUNT(*) FROM synced_files")
|
||||
total_files = cursor.fetchone()[0]
|
||||
|
||||
cursor.execute("SELECT SUM(file_size) FROM synced_files")
|
||||
total_size = cursor.fetchone()[0] or 0
|
||||
|
||||
conn.close()
|
||||
|
||||
return {
|
||||
"total_files": total_files,
|
||||
"total_size": total_size
|
||||
}
|
||||
|
||||
|
||||
class UserMapper:
|
||||
"""Маппинг пользователей Nextcloud -> Authentik"""
|
||||
|
||||
def __init__(self, config: WorkerConfig):
|
||||
"""
|
||||
Инициализация маппера пользователей
|
||||
|
||||
Args:
|
||||
config: Конфигурация воркера
|
||||
"""
|
||||
self.config = config
|
||||
# Кеш маппинга (в production можно использовать БД или Authentik API)
|
||||
self._cache: Dict[str, str] = {}
|
||||
|
||||
def map_nextcloud_user_to_authentik(self, nc_username: str) -> Optional[str]:
|
||||
"""
|
||||
Маппинг имени пользователя Nextcloud в user_id Authentik
|
||||
|
||||
Args:
|
||||
nc_username: Имя пользователя в Nextcloud
|
||||
|
||||
Returns:
|
||||
user_id Authentik или None если маппинг не найден
|
||||
"""
|
||||
# Проверка кеша
|
||||
if nc_username in self._cache:
|
||||
return self._cache[nc_username]
|
||||
|
||||
# В production здесь должен быть запрос к Authentik API
|
||||
# или использование общей БД пользователей
|
||||
# Пока используем простое предположение: username совпадает
|
||||
# или можно настроить через переменные окружения
|
||||
|
||||
# Попытка получить из переменных окружения (формат: NC_USER_username=AUTHENTIK_USER_ID)
|
||||
env_key = f"NC_USER_{nc_username}"
|
||||
authentik_user_id = None
|
||||
|
||||
import os
|
||||
if env_key in os.environ:
|
||||
authentik_user_id = os.environ[env_key]
|
||||
else:
|
||||
# По умолчанию предполагаем, что username совпадает
|
||||
# В production это должно быть через Authentik API
|
||||
authentik_user_id = nc_username
|
||||
|
||||
self._cache[nc_username] = authentik_user_id
|
||||
return authentik_user_id
|
||||
|
||||
def get_user_groups(self, nc_username: str) -> List[str]:
|
||||
"""
|
||||
Получение списка групп доступа для пользователя
|
||||
|
||||
Args:
|
||||
nc_username: Имя пользователя Nextcloud
|
||||
|
||||
Returns:
|
||||
Список групп доступа
|
||||
"""
|
||||
# В production получать из Authentik API или Nextcloud групп
|
||||
# Пока возвращаем пустой список (только личные файлы)
|
||||
return []
|
||||
|
||||
|
||||
class NextcloudSyncWorker:
|
||||
"""Основной класс воркера синхронизации"""
|
||||
|
||||
def __init__(self, config: WorkerConfig):
|
||||
"""
|
||||
Инициализация воркера
|
||||
|
||||
Args:
|
||||
config: Конфигурация воркера
|
||||
"""
|
||||
self.config = config
|
||||
self.nc_client = NextcloudClient(
|
||||
config.nextcloud.url,
|
||||
config.nextcloud.username,
|
||||
config.nextcloud.password
|
||||
)
|
||||
self.webui_client = OpenWebUIClient(
|
||||
config.openwebui.api_url,
|
||||
config.openwebui.api_key,
|
||||
config.openwebui.timeout
|
||||
)
|
||||
self.processor = DocumentProcessor(config.max_file_size)
|
||||
self.state_db = SyncStateDB(config.db_path)
|
||||
self.user_mapper = UserMapper(config)
|
||||
|
||||
def sync_path(self, path_template: str) -> int:
|
||||
"""
|
||||
Синхронизация указанного пути
|
||||
|
||||
Args:
|
||||
path_template: Шаблон пути (может содержать {username})
|
||||
|
||||
Returns:
|
||||
Количество синхронизированных файлов
|
||||
"""
|
||||
synced_count = 0
|
||||
|
||||
# Замена {username} в шаблоне пути
|
||||
if "{username}" in path_template:
|
||||
# Сканируем все домашние директории
|
||||
# В production можно получить список пользователей из Nextcloud API
|
||||
username = self.config.nextcloud.username
|
||||
path = path_template.replace("{username}", username)
|
||||
else:
|
||||
path = path_template
|
||||
|
||||
try:
|
||||
logger.info(f"Сканирование пути: {path}")
|
||||
files = self.nc_client.scan_directory_recursive(path)
|
||||
logger.info(f"Найдено файлов: {len(files)}")
|
||||
|
||||
for file_info in files:
|
||||
try:
|
||||
if self._sync_file(file_info, path_template):
|
||||
synced_count += 1
|
||||
except Exception as e:
|
||||
logger.error(f"Ошибка при синхронизации файла {file_info['path']}: {e}")
|
||||
continue
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Ошибка при сканировании пути {path}: {e}")
|
||||
|
||||
return synced_count
|
||||
|
||||
def _sync_file(self, file_info: Dict, path_template: str) -> bool:
|
||||
"""
|
||||
Синхронизация одного файла
|
||||
|
||||
Args:
|
||||
file_info: Информация о файле
|
||||
path_template: Шаблон пути (для определения владельца)
|
||||
|
||||
Returns:
|
||||
True если файл был синхронизирован
|
||||
"""
|
||||
file_path = file_info["path"]
|
||||
file_size = file_info.get("size", 0)
|
||||
|
||||
# Пропускаем слишком большие файлы
|
||||
if file_size > self.config.max_file_size * 2: # Двойной лимит для безопасности
|
||||
logger.warning(f"Файл {file_path} слишком большой ({file_size} bytes), пропуск")
|
||||
return False
|
||||
|
||||
# Проверка поддержки формата
|
||||
if not self.processor.is_supported_format(file_path, file_info.get("type")):
|
||||
logger.debug(f"Неподдерживаемый формат: {file_path}")
|
||||
return False
|
||||
|
||||
try:
|
||||
# Загрузка файла
|
||||
file_content = self.nc_client.download_file(file_path)
|
||||
file_hash = self.state_db.get_file_hash(file_path, file_content)
|
||||
|
||||
# Проверка, не синхронизирован ли уже файл
|
||||
if self.state_db.is_file_synced(file_path, file_hash):
|
||||
logger.debug(f"Файл уже синхронизирован: {file_path}")
|
||||
return False
|
||||
|
||||
# Обработка файла
|
||||
text_content, is_large = self.processor.process_file(
|
||||
file_content,
|
||||
Path(file_path).name,
|
||||
file_info.get("type")
|
||||
)
|
||||
|
||||
# Определение владельца файла
|
||||
username = self.nc_client.extract_username_from_path(file_path)
|
||||
if not username:
|
||||
# Для общих папок используем None или специальную группу
|
||||
username = None
|
||||
|
||||
user_id = self.user_mapper.map_nextcloud_user_to_authentik(username) if username else None
|
||||
access_groups = self.user_mapper.get_user_groups(username) if username else []
|
||||
|
||||
# Метаданные для API
|
||||
metadata = {
|
||||
"source": "nextcloud",
|
||||
"path": file_path,
|
||||
"original_size": file_size,
|
||||
"is_large_file": is_large
|
||||
}
|
||||
|
||||
# Загрузка в Open WebUI
|
||||
if is_large or len(text_content.encode('utf-8')) > self.config.max_file_size:
|
||||
# Для больших файлов загружаем как текст
|
||||
result = self.webui_client.upload_document_with_text(
|
||||
text_content=text_content,
|
||||
filename=Path(file_path).name,
|
||||
user_id=user_id,
|
||||
access_groups=access_groups,
|
||||
metadata=metadata
|
||||
)
|
||||
else:
|
||||
# Для обычных файлов загружаем оригинал
|
||||
result = self.webui_client.upload_document(
|
||||
file_content=file_content,
|
||||
filename=Path(file_path).name,
|
||||
user_id=user_id,
|
||||
access_groups=access_groups,
|
||||
metadata=metadata
|
||||
)
|
||||
|
||||
# Сохранение состояния
|
||||
document_id = result.get("id") if isinstance(result, dict) else None
|
||||
self.state_db.mark_file_synced(
|
||||
file_path=file_path,
|
||||
file_hash=file_hash,
|
||||
file_size=file_size,
|
||||
last_modified=file_info.get("modified"),
|
||||
user_id=user_id,
|
||||
document_id=document_id
|
||||
)
|
||||
|
||||
logger.info(f"Файл синхронизирован: {file_path} -> документ ID: {document_id}")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Ошибка при синхронизации файла {file_path}: {e}")
|
||||
return False
|
||||
|
||||
def run_once(self):
|
||||
"""Однократный запуск синхронизации"""
|
||||
logger.info("=== Начало синхронизации ===")
|
||||
|
||||
total_synced = 0
|
||||
|
||||
for path_template in self.config.nextcloud.scan_paths:
|
||||
try:
|
||||
synced = self.sync_path(path_template)
|
||||
total_synced += synced
|
||||
logger.info(f"Синхронизировано файлов из {path_template}: {synced}")
|
||||
except Exception as e:
|
||||
logger.error(f"Ошибка при синхронизации пути {path_template}: {e}")
|
||||
|
||||
stats = self.state_db.get_sync_stats()
|
||||
logger.info(f"=== Синхронизация завершена ===")
|
||||
logger.info(f"Всего синхронизировано в этом цикле: {total_synced}")
|
||||
logger.info(f"Всего файлов в БД: {stats['total_files']}")
|
||||
logger.info(f"Общий размер: {stats['total_size'] / 1024 / 1024:.2f} MB")
|
||||
|
||||
def run_daemon(self):
|
||||
"""Запуск воркера в режиме daemon (бесконечный цикл)"""
|
||||
logger.info("Запуск воркера в режиме daemon")
|
||||
logger.info(f"Интервал синхронизации: {self.config.sync_interval} секунд")
|
||||
|
||||
try:
|
||||
while True:
|
||||
self.run_once()
|
||||
logger.info(f"Ожидание {self.config.sync_interval} секунд до следующей синхронизации...")
|
||||
time.sleep(self.config.sync_interval)
|
||||
except KeyboardInterrupt:
|
||||
logger.info("Получен сигнал остановки, завершение работы...")
|
||||
finally:
|
||||
self.cleanup()
|
||||
|
||||
def cleanup(self):
|
||||
"""Очистка ресурсов"""
|
||||
logger.info("Очистка ресурсов...")
|
||||
self.nc_client.close()
|
||||
self.webui_client.close()
|
||||
|
||||
|
||||
def main():
|
||||
"""Точка входа"""
|
||||
import argparse
|
||||
|
||||
parser = argparse.ArgumentParser(description="Воркер синхронизации Nextcloud -> Qdrant")
|
||||
parser.add_argument(
|
||||
"--once",
|
||||
action="store_true",
|
||||
help="Запустить синхронизацию один раз и выйти"
|
||||
)
|
||||
parser.add_argument(
|
||||
"--daemon",
|
||||
action="store_true",
|
||||
help="Запустить в режиме daemon (бесконечный цикл)"
|
||||
)
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
try:
|
||||
config = load_config()
|
||||
worker = NextcloudSyncWorker(config)
|
||||
|
||||
if args.once:
|
||||
worker.run_once()
|
||||
elif args.daemon:
|
||||
worker.run_daemon()
|
||||
else:
|
||||
# По умолчанию запускаем один раз
|
||||
worker.run_once()
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Критическая ошибка: {e}", exc_info=True)
|
||||
sys.exit(1)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in New Issue
Block a user