feat: simply code

Author: cr7258

.env

@@ -1,9 +1,9 @@
 # Elasticsearch connection settings
-ELASTICSEARCH_HOST=https://localhost:9200
+ELASTICSEARCH_HOSTS=https://localhost:9200
 ELASTICSEARCH_USERNAME=elastic
 ELASTICSEARCH_PASSWORD=test123
 
 # OpenSearch connection settings
-OPENSEARCH_HOST=https://localhost:9200
+OPENSEARCH_HOSTS=https://localhost:9200
 OPENSEARCH_USERNAME=elastic
 OPENSEARCH_PASSWORD=test123

src/clients/__init__.py

@@ -1,33 +1,45 @@
-from typing import Dict
-from .elasticsearch.client import ElasticsearchClient
-from .opensearch.client import OpenSearchClient
-from .interfaces import SearchClient
+# Python 内置包
+import os
 
-def create_search_client(config: Dict, engine_type: str) -> SearchClient:
+# 第三方包
+from dotenv import load_dotenv
+
+# 本项目包
+from src.clients.common.client import SearchClient
+from src.clients.exceptions import handle_search_exceptions
+
+def create_search_client(engine_type: str) -> SearchClient:
     """
-    Factory function to create the appropriate search client.
+    Create a search client for the specified engine type.
     
     Args:
-        config: Configuration dictionary with connection parameters
         engine_type: Type of search engine to use ("elasticsearch" or "opensearch")
         
     Returns:
-        SearchClient: An instance of the appropriate search client
-        
-    Raises:
-        ValueError: If an invalid engine type is specified
+        A search client instance
     """
-    if engine_type.lower() == "elasticsearch":
-        return ElasticsearchClient(config)
-    elif engine_type.lower() == "opensearch":
-        return OpenSearchClient(config)
-    else:
-        raise ValueError(f"Invalid engine type: {engine_type}. Must be 'elasticsearch' or 'opensearch'")
+    # Load configuration from environment variables
+    load_dotenv()
+    
+    # Get configuration from environment variables
+    prefix = engine_type.upper()
+    hosts_str = os.environ.get(f"{prefix}_HOSTS", "https://localhost:9200")
+    hosts = [host.strip() for host in hosts_str.split(",")]
+    username = os.environ.get(f"{prefix}_USERNAME")
+    password = os.environ.get(f"{prefix}_PASSWORD")
+    verify_certs = os.environ.get(f"{prefix}_VERIFY_CERTS", "false").lower() == "true"
+    
+    config = {
+        "hosts": hosts,
+        "username": username,
+        "password": password,
+        "verify_certs": verify_certs
+    }
+    
+    return SearchClient(config, engine_type)
 
 __all__ = [
     'create_search_client',
     'handle_search_exceptions',
     'SearchClient',
-    'ElasticsearchClient',
-    'OpenSearchClient',
 ]

src/clients/base.py

@@ -1,24 +1,54 @@
-"""
-Base classes and interfaces for search clients.
-"""
-from abc import ABC, abstractmethod
+from abc import ABC
 import logging
+import warnings
 from typing import Dict
 
 class SearchClientBase(ABC):
-    """Base abstract class for search clients with common functionality."""
-    
-    def __init__(self, config: Dict):
+    def __init__(self, config: Dict, engine_type: str):
         """
-        Initialize the base search client.
+        Initialize the search client.
         
         Args:
             config: Configuration dictionary with connection parameters
+            engine_type: Type of search engine to use ("elasticsearch" or "opensearch")
         """
-        self.logger = logging.getLogger(self.__class__.__name__)
+        self.logger = logging.getLogger()
         self.config = config
-    
-    @abstractmethod
-    def close(self):
-        """Close the client connection."""
-        pass
+        self.engine_type = engine_type
+        
+        # Extract common configuration
+        hosts = config.get("hosts")
+        username = config.get("username")
+        password = config.get("password")
+        verify_certs = config.get("verify_certs", False)
+        
+        # Disable insecure request warnings if verify_certs is False
+        if not verify_certs:
+            warnings.filterwarnings("ignore", message=".*TLS with verify_certs=False is insecure.*")
+            warnings.filterwarnings("ignore", message=".*Unverified HTTPS request is being made to host.*")
+            
+            try:
+                import urllib3
+                urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+            except ImportError:
+                pass
+        
+        # Initialize client based on engine type
+        if engine_type == "elasticsearch":
+            from elasticsearch import Elasticsearch
+            self.client = Elasticsearch(
+                hosts=hosts,
+                basic_auth=(username, password) if username and password else None,
+                verify_certs=verify_certs
+            )
+            self.logger.info(f"Elasticsearch client initialized with hosts: {hosts}")
+        elif engine_type == "opensearch":
+            from opensearchpy import OpenSearch
+            self.client = OpenSearch(
+                hosts=hosts,
+                http_auth=(username, password) if username and password else None,
+                verify_certs=verify_certs
+            )
+            self.logger.info(f"OpenSearch client initialized with hosts: {hosts}")
+        else:
+            raise ValueError(f"Unsupported engine type: {engine_type}")

src/clients/common/__init__.py

@@ -0,0 +1,6 @@
+from .index import IndexClient
+from .document import DocumentClient
+from .cluster import ClusterClient
+from .alias import AliasClient
+
+__all__ = ['IndexClient', 'DocumentClient', 'ClusterClient', 'AliasClient']

src/clients/opensearch/alias.py src/clients/common/alias.py

@@ -1,8 +1,8 @@
 from typing import Dict
-from .base import BaseOpenSearchClient
-from ..interfaces.alias import AliasClientInterface
 
-class OpenSearchAliasClient(BaseOpenSearchClient, AliasClientInterface):
+from src.clients.base import SearchClientBase
+
+class AliasClient(SearchClientBase):
     def list_aliases(self) -> Dict:
         """Get all aliases."""
         return self.client.cat.aliases()

src/clients/common/client.py

@@ -0,0 +1,25 @@
+from typing import Dict
+
+from src.clients.common.alias import AliasClient
+from src.clients.common.cluster import ClusterClient
+from src.clients.common.document import DocumentClient
+from src.clients.common.index import IndexClient
+
+class SearchClient(IndexClient, DocumentClient, ClusterClient, AliasClient):
+    """
+    Unified search client that combines all search functionality.
+    
+    This class uses multiple inheritance to combine all specialized client implementations
+    (index, document, cluster, alias) into a single unified client.
+    """
+    
+    def __init__(self, config: Dict, engine_type: str):
+        """
+        Initialize the search client.
+        
+        Args:
+            config: Configuration dictionary with connection parameters
+            engine_type: Type of search engine to use ("elasticsearch" or "opensearch")
+        """
+        super().__init__(config, engine_type)
+        self.logger.info(f"Initialized the {engine_type} client")

src/clients/common/cluster.py

@@ -0,0 +1,12 @@
+from typing import Dict
+
+from src.clients.base import SearchClientBase
+
+class ClusterClient(SearchClientBase):
+    def get_cluster_health(self) -> Dict:
+        """Get cluster health information from OpenSearch."""
+        return self.client.cluster.health()
+    
+    def get_cluster_stats(self) -> Dict:
+        """Get cluster statistics from OpenSearch."""
+        return self.client.cluster.stats()

src/clients/opensearch/document.py src/clients/common/document.py

@@ -1,8 +1,8 @@
 from typing import Dict, Optional
-from .base import BaseOpenSearchClient
-from ..interfaces.document import DocumentClientInterface
 
-class OpenSearchDocumentClient(BaseOpenSearchClient, DocumentClientInterface):
+from src.clients.base import SearchClientBase
+
+class DocumentClient(SearchClientBase):
     def search_documents(self, index: str, body: Dict) -> Dict:
         """Search for documents in the index."""
         return self.client.search(index=index, body=body)
@@ -25,3 +25,4 @@ def delete_document(self, index: str, id: str) -> Dict:
     def delete_by_query(self, index: str, body: Dict) -> Dict:
         """Deletes documents matching the provided query."""
         return self.client.delete_by_query(index=index, body=body)
+

src/clients/opensearch/index.py src/clients/common/index.py

@@ -1,8 +1,8 @@
 from typing import Dict, Optional
-from .base import BaseOpenSearchClient
-from ..interfaces.index import IndexClientInterface
 
-class OpenSearchIndexClient(BaseOpenSearchClient, IndexClientInterface):    
+from src.clients.base import SearchClientBase
+
+class IndexClient(SearchClientBase):
     def list_indices(self) -> Dict:
         """List all indices."""
         return self.client.cat.indices()