framework code has been completed basicly. Through the use of aios_shell, we are now able to get agents run able (at openai compute node)

src/aios_kernel/compute_kernel.py

@@ -2,32 +2,39 @@ from abc import ABC, abstractmethod
 from typing import Optional
 import logging
 import asyncio
+from asyncio import Queue
 
 from .agent import AgentPrompt
 from .compute_node import ComputeNode
+from .compute_task import ComputeTask,ComputeTaskState,ComputeTaskResult
 
 logger = logging.getLogger(__name__)
 
 # How to dispatch different computing tasks (some tasks may contain a large amount of state for correct execution)
 # to suitable computing nodes, achieving a balance of speed, cost, and power consumption, 
 # is the CORE GOAL of the entire computing task schedule system (aios_kernel).
-class ComputeTask(ABC):
-    @abstractmethod
-    def display(self) -> str:    
-        pass   
-
-
 class ComputeKernel:
     _instance = None
     def __new__(cls):
         if cls._instance is None:
-            cls._instance = super(ComputeKernel, cls).__new__(cls)
+            cls._instance = super().__new__(cls)
+            cls._instance.is_start = False
+        else:
+            print("ComputeKernel is already created!")
         return cls._instance
 
     def __init__(self) -> None:
-        self.task_queue = []
+        if self.is_start is True:
+            print("ComputeKernel is already start!")
+            return
+        
+        print("init ComputeKernel!!!")
+        self.is_start = True
+        self.task_queue = Queue()
         self.is_start = False
-        pass
+        self.compute_nodes = {}
+
+        self.start()
 
     def run(self,task:ComputeTask) -> None:
         # check there is compute node can support this task
@@ -35,7 +42,7 @@ class ComputeKernel:
             logger.error(f"task {task.display()} is not support by any compute node")
             return
         # add task to working_queue
-        self.task_queue.append(task)
+        self.task_queue.put_nowait(task)
         
 
     def start(self):
@@ -46,32 +53,72 @@ class ComputeKernel:
         self.is_start = True
         async def _run_task_loop():
             while True:
-                task = self.task_queue.pop(0)
-                c_node:ComputeNode= await self._schedule(task)
-                c_node.push_task(task)
+                logger.info("compute_kernel is waiting for task...")
+                task = await self.task_queue.get()
+                logger.info(f"compute_kernel get task: {task.display()}")
+                c_node:ComputeNode = self._schedule(task)
+                await c_node.push_task(task)
+            
+            logger.warn("compute_kernel is stoped!")
         
         asyncio.create_task(_run_task_loop())
         
 
-    async def _schedule(self,task) -> ComputeNode:
-        pass
+    def _schedule(self,task) -> ComputeNode:
+        for node in self.compute_nodes.values():
+            if node.is_support(task) is True:
+                return node
+        logger.warning(f"task {task.display()} is not support by any compute node")
+        return None
 
     def add_compute_node(self,node:ComputeNode):
-        pass
+        if self.compute_nodes.get(node.node_id) is not None:
+            logger.warn(f"compute_node {node.display()} already in compute_kernel")
+            return
+        self.compute_nodes[node.node_id] = node
+        logger.info(f"add compute_node {node.display()} to compute_kernel")
 
-    def disable_compute_node(self,):
-        pass
+    def disable_compute_node(self,node_id:str):
+        node = self.compute_nodes.get(node_id)
+        if node is None:
+            logger.warn(f"compute_node {node_id} not in compute_kernel")
+            return
+        node.enable = False
 
     def is_task_support(self,task:ComputeTask) -> bool:
-        pass
+        return True
 
 
     # friendly interface for use:
-    def llm_completion(self,prompt:AgentPrompt,mode_name:Optional[str] = None,max_token:int = 0) -> ComputeTask:
+    def llm_completion(self,prompt:AgentPrompt,mode_name:Optional[str] = None,max_token:int = 0):
         # craete a llm_work_task ,push on queue's end
         # then task_schedule would run this task.(might schedule some work_task to another host)
-        pass
+        task_req = ComputeTask()
+        task_req.set_llm_params(prompt,mode_name,max_token)
+        self.run(task_req)
+        return task_req
 
     async def do_llm_completion(self,prompt:AgentPrompt,mode_name:Optional[str] = None,max_token:int = 0) -> str:
-        pass
+        task_req = self.llm_completion(prompt,mode_name,max_token)
+        async def check_timer():
+            check_times = 0
+            while True:
+                if task_req.state == ComputeTaskState.DONE:
+                    break
+
+                if task_req.state == ComputeTaskState.ERROR:
+                    break
+
+                if check_times >=  20:
+                    task_req.state = ComputeTaskState.ERROR
+                    break
+
+                await asyncio.sleep(0.5)
+                check_times += 1
+            
+        await asyncio.create_task(check_timer())
+        if task_req.state == ComputeTaskState.DONE:
+            return task_req.result.result_str
+              
+        return "error!"