Исправление проблемы с кэшем Go и предварительная компиляция API сервера

Dockerfile

@@ -34,6 +34,10 @@ ENV GOPATH=/go
 ENV PATH=$PATH:$GOPATH/bin
 RUN mkdir -p /go && chmod 777 /go
 
+# Создание директории для кэша Go
+ENV GOCACHE=/tmp/go-cache
+RUN mkdir -p /tmp/go-cache && chmod 777 /tmp/go-cache
+
 # Установка Node.js и pnpm
 RUN curl -fsSL https://deb.nodesource.com/setup_20.x | bash - && \
     apt-get install -y nodejs && \
@@ -43,8 +47,20 @@ RUN curl -fsSL https://deb.nodesource.com/setup_20.x | bash - && \
 WORKDIR /app
 RUN git clone --depth 1 https://github.com/TEN-framework/TEN-Agent.git /app
 
-# Создание пользовательской директории для временных файлов
+# Создание пользовательских директорий для временных файлов
 RUN mkdir -p /tmp/ten_user && chmod 777 /tmp/ten_user
+RUN mkdir -p /app/fallback && chmod 777 /app/fallback
+
+# Компиляция API сервера
+RUN mkdir -p /app/server/bin && \
+    cd /app/server && \
+    GOCACHE=/tmp/go-cache go build -o bin/api main.go && \
+    chmod +x bin/api && \
+    cp bin/api /app/fallback/api && \
+    chmod 777 /app/fallback/api
+
+# Проверяем, что API сервер скомпилирован
+RUN ls -la /app/server/bin/api /app/fallback/api
 
 # Создание .env файла из окружения Hugging Face Space
 # Используем простой формат без пробелов для предотвращения ошибок

fallback.py

@@ -21,8 +21,12 @@ def create_user_directory():
     server_bin_dir = user_dir / "server" / "bin"
     server_bin_dir.mkdir(exist_ok=True, parents=True)
     
+    # Создаем директорию для кэша Go
+    go_cache_dir = Path("/tmp/go-cache")
+    go_cache_dir.mkdir(exist_ok=True, parents=True)
+    
     print(f"Created directory structure at {user_dir}")
-    return user_dir, agents_dir, server_bin_dir
+    return user_dir, agents_dir, server_bin_dir, go_cache_dir
 
 def create_basic_files(agents_dir):
     """Создает базовые файлы конфигурации для TEN-Agent"""
@@ -129,46 +133,54 @@ def create_basic_files(agents_dir):
     
     print("Basic configuration files created successfully.")
 
-def check_api_server(server_bin_dir):
-    """Проверяет наличие API сервера и компилирует его при необходимости"""
+def copy_api_server(server_bin_dir):
+    """Копирует предварительно скомпилированный API сервер"""
     api_bin = server_bin_dir / "api"
     
-    if not api_bin.exists():
-        print("Copying API server binary...")
-        # Проверяем наличие уже скомпилированного сервера в основном репозитории
-        original_bin = Path("/app/server/bin/api")
-        if original_bin.exists():
-            # Копируем бинарник из основного репозитория
-            shutil.copy(original_bin, api_bin)
-            api_bin.chmod(0o755)  # Делаем исполняемым
-            print(f"API server binary copied to {api_bin}")
-        else:
-            print("Compiling API server from source...")
-            try:
-                # Компилируем сервер
-                result = subprocess.run(
-                    "cd /app/server && go build -o /tmp/ten_user/server/bin/api main.go",
-                    shell=True,
-                    check=True,
-                    stdout=subprocess.PIPE,
-                    stderr=subprocess.PIPE
-                )
-                print(f"API server compiled successfully: {result.stdout.decode()}")
-                # Делаем исполняемым
-                api_bin.chmod(0o755)
-            except subprocess.CalledProcessError as e:
-                print(f"Failed to compile API server: {e.stderr.decode()}")
-                # Как последний вариант, используем предварительно скомпилированный бинарник
-                fallback_bin = Path("/app/fallback/api")
-                if fallback_bin.exists():
-                    shutil.copy(fallback_bin, api_bin)
-                    api_bin.chmod(0o755)
-                    print(f"Using pre-compiled fallback API server binary")
-                else:
-                    print("No API server binary available! Cannot continue.")
-                    return False
+    # Приоритезируем API сервер из директории fallback
+    fallback_bin = Path("/app/fallback/api")
+    if fallback_bin.exists():
+        print(f"Found pre-compiled API server at {fallback_bin}")
+        shutil.copy(fallback_bin, api_bin)
+        api_bin.chmod(0o755)  # Делаем исполняемым
+        print(f"API server binary copied to {api_bin}")
+        return True
+    
+    # Ищем API сервер в основной директории
+    original_bin = Path("/app/server/bin/api")
+    if original_bin.exists():
+        print(f"Found API server at {original_bin}")
+        shutil.copy(original_bin, api_bin)
+        api_bin.chmod(0o755)  # Делаем исполняемым
+        print(f"API server binary copied to {api_bin}")
+        return True
     
-    return True
+    # Если не нашли готовый бинарник, пытаемся компилировать
+    try:
+        print("No pre-compiled API server found, trying to compile from source...")
+        env = os.environ.copy()
+        env["GOCACHE"] = "/tmp/go-cache"  # Указываем директорию для кэша Go
+        env["GOPATH"] = "/tmp/go-path"  # Указываем пользовательский GOPATH
+        
+        # Создаем директорию для GOPATH
+        Path("/tmp/go-path").mkdir(exist_ok=True, parents=True)
+        
+        # Компилируем с пользовательскими настройками
+        result = subprocess.run(
+            "cd /app/server && go build -o /tmp/ten_user/server/bin/api main.go",
+            shell=True,
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            env=env
+        )
+        print(f"Successfully compiled API server: {result.stdout.decode()}")
+        api_bin.chmod(0o755)
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"Failed to compile API server: {e.stderr.decode()}")
+        print("Critical error: No API server available!")
+        return False
 
 def main():
     try:
@@ -179,18 +191,34 @@ def main():
         user = os.environ.get('USER', 'unknown')
         print(f"Current user: {user}")
         print(f"HOME: {os.environ.get('HOME', 'unset')}")
+        print(f"PATH: {os.environ.get('PATH', 'unset')}")
         
         # Создаем пользовательские директории
-        user_dir, agents_dir, server_bin_dir = create_user_directory()
+        user_dir, agents_dir, server_bin_dir, go_cache_dir = create_user_directory()
         
         # Создаем базовые конфигурационные файлы
         create_basic_files(agents_dir)
         
-        # Проверяем API сервер
-        if not check_api_server(server_bin_dir):
+        # Копируем API сервер
+        if not copy_api_server(server_bin_dir):
             print("Critical error: Cannot prepare API server")
             sys.exit(1)
         
+        # Проверяем, что API сервер действительно скопирован и исполняемый
+        api_bin = server_bin_dir / "api"
+        if not api_bin.exists():
+            print(f"Critical error: API server binary not found at {api_bin}")
+            sys.exit(1)
+            
+        try:
+            api_bin.chmod(0o755)  # Дополнительно проверяем права
+        except Exception as e:
+            print(f"Warning: Could not set execute permissions on API server binary: {e}")
+            # Продолжаем, возможно, права уже установлены
+        
+        print(f"API server binary prepared successfully: {api_bin}")
+        print(f"File exists: {api_bin.exists()}, size: {api_bin.stat().st_size} bytes")
+        
         # Установка переменных среды
         os.environ["PORT"] = "7860"  # HuggingFace использует порт 7860
         os.environ["AGENT_SERVER_URL"] = "http://localhost:8080"
@@ -198,19 +226,29 @@ def main():
         os.environ["NEXT_PUBLIC_DISABLE_CAMERA"] = "true"
         
         # Путь к бинарнику API сервера
-        api_bin = str(server_bin_dir / "api")
+        api_bin_str = str(api_bin)
         
         # Запускаем API сервер с указанием пути к agents директории
         print(f"Starting API server with agents directory: {agents_dir}")
         api_env = os.environ.copy()
         api_env["TEN_AGENT_DIR"] = str(agents_dir)
+        api_env["GOCACHE"] = str(go_cache_dir)  # Устанавливаем переменную GOCACHE
         
-        api_process = subprocess.Popen(
-            [api_bin],
-            env=api_env,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE
-        )
+        # Дополнительно проверяем права на исполнение через ls -la
+        subprocess.run(["ls", "-la", api_bin_str], check=True)
+        
+        # Запускаем API сервер
+        print(f"Executing API server: {api_bin_str}")
+        try:
+            api_process = subprocess.Popen(
+                [api_bin_str],
+                env=api_env,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE
+            )
+        except Exception as e:
+            print(f"Failed to start API server: {e}")
+            sys.exit(1)
         
         # Даем серверу время для запуска
         time.sleep(5)