added the protoc handler if the google protoc being used

Author: aditya0yadav

src/dubbo/codec/protobuf_codec/__init__.py

@@ -16,13 +16,18 @@
 
 from .protobuf_codec import ProtobufTransportCodec, ProtobufTransportDecoder, ProtobufTransportEncoder
 from .protobuf_base import ProtobufEncoder, ProtobufDecoder
-from .betterproto_handler import BetterprotoMessageHandler, PrimitiveHandler
+from .betterproto_handler import BetterprotoMessageHandler
+from .protoc_handler import GoogleProtobufMessageHandler
+from .primitive_handler import PrimitiveHandler
 
 __all__ = [
     "ProtobufTransportCodec",
     "ProtobufTransportDecoder",
     "ProtobufTransportEncoder",
     "ProtobufEncoder",
-    "ProtobufDecoderBetterprotoMessageHandler",
+    "ProtobufDecoder",
+    "BetterprotoMessageHandler",
+    "PrimitiveHandler",
+    "GoogleProtobufMessageHandler",
     "PrimitiveHandler",
 ]

src/dubbo/codec/protobuf_codec/primitive_handler.py

@@ -0,0 +1,108 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+from typing import Any, Optional
+
+from .protobuf_base import ProtobufEncoder, ProtobufDecoder, SerializationException, DeserializationException
+
+
+__all__ = ["PrimitiveHandler"]
+
+
+class PrimitiveHandler(ProtobufEncoder, ProtobufDecoder):
+    """
+    The primitive type handler for basic Python types.
+    """
+
+    _SERIALIZATION_TYPE = "primitive"
+
+    @classmethod
+    def get_serialization_type(cls) -> str:
+        """
+        Get serialization type of current implementation
+        :return: The serialization type.
+        :rtype: str
+        """
+        return cls._SERIALIZATION_TYPE
+
+    def can_handle(self, obj: Any, obj_type: Optional[type] = None) -> bool:
+        """
+        Check if this handler can handle the given object/type
+        :param obj: The object to check
+        :param obj_type: The type to check
+        :return: True if can handle, False otherwise
+        :rtype: bool
+        """
+        if obj is not None:
+            return isinstance(obj, (str, int, float, bool, bytes))
+        if obj_type is not None:
+            return obj_type in (str, int, float, bool, bytes)
+        return False
+
+    def encode(self, obj: Any, obj_type: Optional[type] = None) -> bytes:
+        """
+        Encode the primitive object to bytes.
+        :param obj: The object to encode.
+        :param obj_type: The type hint for encoding.
+        :return: The encoded bytes.
+        :rtype: bytes
+        """
+        try:
+            if not isinstance(obj, (str, int, float, bool, bytes)):
+                raise SerializationException(f"Cannot encode {type(obj)} as primitive")
+
+            json_str = json.dumps({"value": obj, "type": type(obj).__name__})
+            return json_str.encode("utf-8")
+        except Exception as e:
+            raise SerializationException(f"Primitive encoding failed: {e}") from e
+
+    def decode(self, data: bytes, target_type: type) -> Any:
+        """
+        Decode the data to primitive object.
+        :param data: The data to decode.
+        :param target_type: The target primitive type.
+        :return: The decoded object.
+        :rtype: Any
+        """
+        try:
+            if target_type not in (str, int, float, bool, bytes):
+                raise DeserializationException(f"{target_type} is not a supported primitive type")
+
+            json_str = data.decode("utf-8")
+            parsed = json.loads(json_str)
+            value = parsed.get("value")
+
+            if target_type is str:
+                return str(value)
+            elif target_type is int:
+                return int(value)
+            elif target_type is float:
+                return float(value)
+            elif target_type is bool:
+                return bool(value)
+            elif target_type is bytes:
+                if isinstance(value, bytes):
+                    return value
+                elif isinstance(value, list):
+                    return bytes(value)
+                else:
+                    return str(value).encode()
+            else:
+                return value
+
+        except Exception as e:
+            raise DeserializationException(f"Primitive decoding failed: {e}") from e

src/dubbo/codec/protobuf_codec/protobuf_codec.py

@@ -17,7 +17,6 @@
 from typing import Any, Optional, List
 
 from .protobuf_base import ProtobufEncoder, ProtobufDecoder, SerializationException, DeserializationException
-from .protobuf_base import ProtobufEncoder
 
 __all__ = ["ProtobufTransportCodec"]
 
@@ -83,8 +82,7 @@ def decode(self, data: bytes) -> Any:
 
 class ProtobufTransportCodec:
     """
-    Main protobuf codec class compatible with extension loader.
-    This class provides encoder() and decoder() methods as expected by the extension loader.
+    Main protobuf codec class
     """
 
     def __init__(
@@ -107,35 +105,36 @@ def _load_default_handlers(self):
         """Load default encoding and decoding handlers"""
         from dubbo.extension import extensionLoader
 
+        # Try BetterProto handler
         try:
-            # Try to load BetterProto handler
-            name = "message"
-            message_handler = extensionLoader.get_extension(ProtobufEncoder, name)
-            betterproto_handler = message_handler()
+            betterproto_handler = extensionLoader.get_extension(ProtobufEncoder, "betterproto")()
             self._encoders.append(betterproto_handler)
             self._decoders.append(betterproto_handler)
         except ImportError:
             print("Warning: BetterProto handler not available")
 
-        # Load primitive handler
-        from dubbo.extension import extensionLoader
+        # Try Google Protoc handler
+        try:
+            protoc_handler = extensionLoader.get_extension(ProtobufEncoder, "googleproto")()
+            self._encoders.append(protoc_handler)
+            self._decoders.append(protoc_handler)
+        except ImportError:
+            print("Warning: Protoc handler not available")
 
-        name = "primitive"
-        primitive_handler = extensionLoader.get_extension(ProtobufEncoder, name)()
+        # Always load primitive handler
+        primitive_handler = extensionLoader.get_extension(ProtobufEncoder, "primitive")()
         self._encoders.append(primitive_handler)
         self._decoders.append(primitive_handler)
 
     def encoder(self) -> ProtobufTransportEncoder:
         """
         Create and return an encoder instance.
-        This method is called by the extension loader / DubboSerializationService.
         """
         return ProtobufTransportEncoder(self._encoders, self._parameter_types)
 
     def decoder(self) -> ProtobufTransportDecoder:
         """
         Create and return a decoder instance.
-        This method is called by the extension loader / DubboSerializationService.
         """
         return ProtobufTransportDecoder(self._decoders, self._return_type)
 

src/dubbo/codec/protobuf_codec/protoc_handler.py

@@ -0,0 +1,82 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Any, Optional
+from .protobuf_base import ProtobufEncoder, ProtobufDecoder, SerializationException, DeserializationException
+
+try:
+    from google.protobuf.message import Message as GoogleMessage
+
+    HAS_PROTOC = True
+except ImportError:
+    HAS_PROTOC = False
+
+
+class GoogleProtobufMessageHandler(ProtobufEncoder, ProtobufDecoder):
+    """
+    The Google protoc message handler for protobuf messages.
+    """
+
+    _SERIALIZATION_TYPE = "protoc"
+
+    def __init__(self):
+        if not HAS_PROTOC:
+            raise ImportError("google.protobuf is required for GoogleProtobufMessageHandler")
+
+    @classmethod
+    def get_serialization_type(cls) -> str:
+        return cls._SERIALIZATION_TYPE
+
+    def can_handle(self, obj: Any, obj_type: Optional[type] = None) -> bool:
+        if obj is not None and HAS_PROTOC and isinstance(obj, GoogleMessage):
+            return True
+        if obj_type is not None:
+            return self._is_protoc_message(obj_type)
+        return False
+
+    def encode(self, obj: Any, obj_type: Optional[type] = None) -> bytes:
+        try:
+            if isinstance(obj, GoogleMessage):
+                return obj.SerializeToString()
+
+            if obj_type and self._is_protoc_message(obj_type):
+                if isinstance(obj, obj_type):
+                    return obj.SerializeToString()
+                elif isinstance(obj, dict):
+                    message = obj_type(**obj)
+                    return message.SerializeToString()
+                else:
+                    raise SerializationException(f"Cannot convert {type(obj)} to {obj_type}")
+
+            raise SerializationException(f"Cannot encode {type(obj)} as protoc message")
+        except Exception as e:
+            raise SerializationException(f"Protoc encoding failed: {e}") from e
+
+    def decode(self, data: bytes, target_type: type) -> Any:
+        try:
+            if not self._is_protoc_message(target_type):
+                raise DeserializationException(f"{target_type} is not a protoc message type")
+            message = target_type()
+            message.ParseFromString(data)
+            return message
+        except Exception as e:
+            raise DeserializationException(f"Protoc decoding failed: {e}") from e
+
+    def _is_protoc_message(self, obj_type: type) -> bool:
+        try:
+            return HAS_PROTOC and issubclass(obj_type, GoogleMessage)
+        except (TypeError, AttributeError):
+            return False