fabric-chaincode-python 2.5.2__py3-none-any.whl

src/fabric_shim/msg_queue_handler.py

@@ -0,0 +1,91 @@
+# SPDX-License-Identifier: Apache-2.0
+import asyncio
+from src.fabric_shim.logging import LOGGER
+
+
+class QueueMessage:
+    def __init__(self, msg, method, future: asyncio.Future) -> None:
+        self.msg = msg
+        self.method = method
+        self.future = future
+
+    def get_msg(self):
+        return self.msg
+
+    def get_msg_txContextId(self):
+        return self.msg.channel_id + self.msg.txid
+
+    def get_method(self):
+        return self.method
+
+    def success(self, response):
+        self.future.set_result(response)
+
+    def fail(self, err):
+        self.future.set_exception(Exception(err))
+
+
+class MsgQueueHandler:
+    """This class handles queuing messages to be sent to the peer based on transaction id"""
+    
+    def __init__(self, handler) -> None:
+        self.handler = handler
+        self.tx_queues = {}
+        self.context = handler.context
+
+    async def queue_msg(self, msg: QueueMessage):
+        """Queue a message to be sent to the peer"""
+        tx_context_id = msg.get_msg_txContextId()
+        msg_queue = self.tx_queues.setdefault(tx_context_id, [])
+        msg_queue.append(msg)
+        if len(msg_queue) == 1:
+            await self.__send_msg(tx_context_id)
+
+    async def __send_msg(self, tx_context_id):
+        """send the current message to the peer"""
+        msg: QueueMessage = self.__get_current_msg(tx_context_id)
+        if msg:
+            try:
+                await self.context.write(msg.get_msg())
+            except Exception as e:
+                msg.fail(e)
+
+    async def handle_msg_response(self, response):
+        tx_id = response.txid
+        channel_id = response.channel_id
+        tx_context_id = channel_id + tx_id
+        msg: QueueMessage = self.__get_current_msg(tx_context_id)
+
+        if msg:
+            try:
+                # parsed_response = parse_response(self.handler, response, msg.get_method())
+                msg.success(response)
+            except Exception as e:
+                msg.fail(e)
+            await self.__remove_current_and_send_next(tx_context_id)
+        else:
+            LOGGER.warning('No queued message found for tx_context_id %s', tx_context_id)
+
+    def __get_current_msg(self, tx_context_id):
+        """returns the message at the top of the queue for the particular transaction"""
+        msg_queue = self.tx_queues.get(tx_context_id)
+        if msg_queue:
+            return msg_queue[0]
+
+        LOGGER.debug('Failed to find a message for transaction context id %s', tx_context_id)
+        return None
+
+    async def __remove_current_and_send_next(self, tx_context_id):
+        """Remove the current message and send the next message in the queue if there is one"""
+        msg_queue = self.tx_queues.get(tx_context_id)
+        if msg_queue and len(msg_queue) > 0:
+            msg_queue.pop(0)
+            if len(msg_queue) != 0:
+                await self.__send_msg(tx_context_id)
+            else:
+                # remove empty queue to free memory
+                try:
+                    del self.tx_queues[tx_context_id]
+                except KeyError:
+                    pass
+                

src/fabric_shim/response.py

@@ -0,0 +1,49 @@
+# SPDX-License-Identifier: Apache-2.0
+from fabric_protos.peer import chaincode_shim_pb2 as ccshim_pb2
+from fabric_protos.peer import proposal_response_pb2 as pb
+
+
+class ResponseCode:
+    """
+    OK constant - status code less than 400, endorser will endorse it.
+    OK means init or invoke successfully.
+
+    ERRORTHRESHOLD constant - status code greater than or equal to 400 will be considered an error and rejected by
+    endorser.
+
+    ERROR constant - default error value
+    """
+    OK, ERRORTHRESHOLD, ERROR = 200, 400, 500
+
+
+def new_error_msg(msg, state) -> ccshim_pb2.ChaincodeMessage:
+    err_str = f"[{msg.txid}] Chaincode h cannot handle message ({msg.type}) while in state: {state}"
+    return ccshim_pb2.ChaincodeMessage(type=ccshim_pb2.ChaincodeMessage.ERROR,
+                                       payload=err_str.encode(encoding='utf-8'), txid=msg.txid)
+
+
+def success(payload):
+    """Build a successful Fabric Response.
+
+    Puts *payload* in the ``payload`` (bytes) field of the Response — this
+    is the field that ``peer chaincode query`` / ``invoke`` reads to print
+    the chaincode result.  ``payload`` may be ``bytes``, ``str`` (will be
+    UTF-8 encoded) or ``None`` (treated as an empty payload).
+    """
+    if payload is None:
+        payload = b""
+    if isinstance(payload, str):
+        payload = payload.encode("utf-8")
+    elif isinstance(payload, bytearray):
+        payload = bytes(payload)
+    return pb.Response(status=ResponseCode.OK, payload=payload)
+
+
+def error(message: str = ""):
+    """Build an error Fabric Response.
+
+    Puts *message* in the ``message`` (string) field of the Response — this
+    is what ``peer chaincode query`` / ``invoke`` prints to stderr when
+    the chaincode returns an error.
+    """
+    return pb.Response(status=ResponseCode.ERROR, message=message)

src/fabric_shim/server.py

@@ -0,0 +1,155 @@
+# SPDX-License-Identifier: Apache-2.0
+import asyncio
+import logging
+import os
+
+from typing import AsyncIterable, Type
+
+import grpc
+import queue
+
+from src.fabric_shim.handler import Handler
+from src.fabric_shim.interfaces import Chaincode
+from src.fabric_shim.logging import LOGGER
+from fabric_protos.peer import chaincode_shim_pb2_grpc as ccshim_grpc_pb2
+from fabric_protos.peer import chaincode_shim_pb2 as ccshim_pb2
+
+# Coroutines to be invoked when the event loop is shutting down.
+_cleanup_coroutines = []
+
+send_queue = queue.SimpleQueue()
+
+
+class ChaincodeService(ccshim_grpc_pb2.ChaincodeServicer):
+    """Chaincode as a server - peer establishes a connection to the chaincode as a client
+    Currently only supports a stream connection.
+    """
+
+    def __init__(self, chaincode_id: str, chaincode: Chaincode):
+        self._ccid = chaincode_id
+        self._cc = chaincode
+
+    async def Connect(self, request_iterator: AsyncIterable[ccshim_pb2.ChaincodeMessage],
+                    context: grpc.aio.ServicerContext) -> None: # Iterable[ccshim_pb2.ChaincodeMessage]:
+        try:
+            handler = Handler(self._ccid, self._cc)
+            await handler.chat_with_peer(request_iterator, context)
+        except asyncio.CancelledError:
+            LOGGER.info("Cancelling RPC due to exhausted resources.")
+            # context.abort()
+
+
+def load_tls_config(key: bytes = None, cert: bytes = None, client_ca_certs: bytes = None) -> grpc.ServerCredentials:
+    """
+    load_tls_config loads the TLS configuration for the chaincode
+
+    Returns:
+      A grpc.ServerCredentials
+    """
+    # Accept either file paths (str) or raw bytes. Normalize to bytes.
+    def _read_bytes(v):
+        if v is None:
+            return None
+        if isinstance(v, (bytes, bytearray)):
+            return bytes(v)
+        if isinstance(v, str):
+            try:
+                with open(v, 'rb') as fh:
+                    return fh.read()
+            except Exception:
+                return v.encode()
+        return v
+
+    key_b = _read_bytes(key)
+    cert_b = _read_bytes(cert)
+    ca_b = _read_bytes(client_ca_certs)
+
+    client_auth = True if ca_b else False
+    # Loading credentials
+    return grpc.ssl_server_credentials(((key_b, cert_b,),), ca_b, client_auth)
+
+
+def _internal_server(**kwargs) -> grpc.aio.Server:
+    server = grpc.aio.server()
+
+    key = kwargs.pop("key", os.getenv('CORE_TLS_CLIENT_KEY_PATH'))
+    cert = kwargs.pop("cert", os.getenv('CORE_TLS_CLIENT_CERT_PATH'))
+    address = kwargs.get("address")
+
+    if not key or not cert:
+        port = server.add_insecure_port(address)
+    else:
+        client_ca_certs = kwargs.pop("client_ca_certs", os.getenv('CORE_PEER_TLS_ROOTCERT_FILE'))
+        server_credentials = load_tls_config(key, cert, client_ca_certs)
+        # Pass down credentials
+        port = server.add_secure_port(address, server_credentials)
+
+    ccid = kwargs.get("ccid")
+    cc = kwargs.pop("cc")
+
+    ccshim_grpc_pb2.add_ChaincodeServicer_to_server(ChaincodeService(ccid, cc), server)
+    logging.info('Server is listening at port :%d', port)
+    return server
+
+
+async def _internal_start(server: grpc.aio.Server) -> None:
+    await server.start()
+
+    async def server_graceful_shutdown():
+        logging.info("Starting graceful shutdown...")
+        # Shuts down the server with 3 seconds of grace period. During the
+        # grace period, the server won't accept new connections and allow
+        # existing RPCs to continue within the grace period.
+        await server.stop(3)
+
+    _cleanup_coroutines.append(server_graceful_shutdown())
+    await server.wait_for_termination()
+
+
+def start(cc: Type[Chaincode],
+          cc_id: str = None,
+          address: str = None,
+          key: bytes = None,
+          cert: bytes = None,
+          client_ca_certs: bytes = None):
+    """
+    start the server
+
+    address  Is the listen address of the chaincode server.
+    key      TLS Private key passed to chaincode server.
+    cert     TLS Certificate passed to chaincode server. Note
+            that this argument is compatible with 'key' - if some
+            are missing, 'TLS disabled'.
+    client_ca_certs   Set if connecting peer should be verified.
+    """
+    cc_id = os.getenv('CHAINCODE_ID', cc_id)
+    address = os.getenv('CHAINCODE_SERVER_ADDRESS', address)
+    if not cc_id:
+        raise Exception("cc_id must be specified")
+    if not address:
+        raise Exception("address must be specified")
+
+    if cc is None:
+        raise Exception("chaincode must be specified")
+
+    # Accept either a Chaincode subclass (class) or an instance implementing Chaincode
+    if isinstance(cc, type):
+        if not issubclass(cc, Chaincode):
+            raise Exception("chaincode must subclass Chaincode")
+        # instantiate the chaincode class
+        try:
+            cc = cc()
+        except Exception as e:
+            raise Exception(f"failed to instantiate chaincode class: {e}")
+    else:
+        if not isinstance(cc, Chaincode):
+            raise Exception("chaincode must be an instance of Chaincode")
+
+    server = _internal_server(ccid=cc_id, address=address, cc=cc, key=key, cert=cert, client_ca_certs=client_ca_certs)
+    loop = asyncio.get_event_loop()
+    try:
+        loop.run_until_complete(_internal_start(server))
+    finally:
+        if _cleanup_coroutines:
+            loop.run_until_complete(asyncio.gather(*_cleanup_coroutines))
+        loop.close()

src/fabric_shim/stub.py

@@ -0,0 +1,342 @@
+# SPDX-License-Identifier: Apache-2.0
+from src.fabric_shim.interfaces import ChaincodeStubInterface
+from src.fabric_shim.utils import (
+    COMPOSITEKEY_NS,
+    MIN_UNICODE_RUNE_VALUE,
+    validate_composite_key_attribute,
+)
+from fabric_protos.peer import chaincode_pb2 as pb
+from fabric_protos.common import common_pb2 as cm_pb
+from fabric_protos.peer import proposal_pb2 as pr_pb
+from fabric_protos.msp import identities_pb2 as id_pb
+from fabric_protos.peer import chaincode_event_pb2 as e_pb
+from collections.abc import Sequence
+from src.fabric_shim.logging import LOGGER
+
+VALIDATION_PARAMETER: str = 'VALIDATION_PARAMETER'
+
+
+class ChaincodeStub(ChaincodeStubInterface):
+    """The stub encapsulates the APIs between the chaincode implementation and the Fabric peer"""
+
+    def __init__(self, client, channel_id, tx_id, cc_input, signed_proposal_pb):
+        self.client = client
+        self.channel_id = channel_id
+        self.tx_id = tx_id
+        self.cc_input = cc_input
+        self.signed_proposal_pb = signed_proposal_pb
+        self.creator = {}
+        self.tx_timestamp = None
+        self.proposal = None
+        self.validationParameterMetakey = VALIDATION_PARAMETER
+
+        if self.signed_proposal_pb:
+            # Only attempt to decode the signed proposal if it contains proposal_bytes
+            proposal_bytes = getattr(self.signed_proposal_pb, 'proposal_bytes', None)
+            if proposal_bytes:
+                decoded_sp = {
+                    'signature': getattr(self.signed_proposal_pb, 'signature', None)
+                }
+                proposal = pr_pb.Proposal.FromString(proposal_bytes)
+                decoded_sp['proposal'] = {}
+                self.proposal = proposal
+
+                if not proposal.header or len(proposal.header) == 0:
+                    raise Exception('Proposal header is empty')
+
+                if not proposal.payload or len(proposal.payload) == 0:
+                    raise Exception('Proposal payload is empty')
+
+                try:
+                    header = cm_pb.Header.FromString(proposal.header)
+                    # Use a dict for the decoded header fields rather than assigning
+                    # the protobuf Header object directly (protobuf objects don't
+                    # support item assignment). Keep the parsed `header` protobuf
+                    # in a local variable for further extraction.
+                    decoded_sp['proposal']['header'] = {}
+                    decoded_sp['proposal']['header']['_raw_header'] = header
+                except Exception as e:
+                    raise Exception('Could not extract the header from the proposal: ' + str(e))
+
+                try:
+                    signature_header = cm_pb.SignatureHeader.FromString(header.signature_header)
+                    decoded_sp['proposal']['header']['signatureHeader'] = \
+                        {'nonce': signature_header.nonce, 'creator_u8': signature_header.creator}
+                except Exception as e:
+                    raise Exception('Decoding SignatureHeader failed: ' + str(e))
+
+                try:
+                    creator = id_pb.SerializedIdentity.FromString(signature_header.creator)
+                    decoded_sp['proposal']['header']['signatureHeader']['creator'] = creator
+                    self.creator = {'mspid': creator.mspid, 'idBytes': creator.id_bytes}
+                except Exception as e:
+                    raise Exception('Decoding SerializedIdentity failed: ' + str(e))
+
+                try:
+                    channel_header = cm_pb.ChannelHeader.FromString(header.channel_header)
+                    decoded_sp['proposal']['header']['channelHeader'] = channel_header
+                    self.tx_timestamp = channel_header.timestamp
+                except Exception as e:
+                    raise Exception('Decoding ChannelHeader failed: ' + str(e))
+
+                try:
+                    ccpp = pr_pb.ChaincodeProposalPayload.FromString(proposal.payload)
+                    decoded_sp['proposal']['payload'] = ccpp
+                except Exception as e:
+                    raise Exception('Decoding ChaincodeProposalPayload failed: %s' + str(e))
+
+                self.signed_proposal_pb = decoded_sp
+            else:
+                # No proposal bytes provided; treat as unsigned/no proposal for tests
+                self.signed_proposal_pb = None
+
+    def get_channel_id(self):
+        """Get the channel ID of the chaincode calling transaction"""
+        return self.channel_id
+
+    def get_tx_timestamp(self):
+        """Get the timestamp of the chaincode calling transaction"""
+        return self.tx_timestamp
+
+    def get_creator(self):
+        """Get the user ID of the chaincode calling transaction"""
+        return self.creator
+
+    def get_txid(self):
+        """Get the ID of the chaincode calling transaction"""
+        return self.tx_id
+
+    def get_function_and_parameters(self):
+        """Get function name and parameters of the chaincode calling transaction"""
+        args = [arg.decode() for arg in self.cc_input.args]
+        if len(args) == 0:
+            raise Exception('no function name provided in transaction payload')
+        function: str = args[0]
+        params = args[1:]
+
+        return function, params
+
+    async def get_state(self, key: str): #-> bytearray:
+        """Get asset state from ledger"""
+        LOGGER.info('get_state called with key:%s' % key)
+        # Access public data by setting the collection to empty string
+        collection = ''
+        return await self.client.handle_get_state(collection, key, self.channel_id, self.tx_id)
+
+    async def put_state(self, key: str, value):
+        """Put asset state to ledger"""
+        LOGGER.info('put_state called with key:%s and value:%s' % (key, value))
+        # Access public data by setting the collection to empty string
+        collection = ''
+        if isinstance(value, str):
+            value = bytes(value.encode())
+        return await self.client.handle_put_state(collection, key, value, self.channel_id, self.tx_id)
+
+    async def delete_state(self, key: str):
+        """Delete asset state from ledger"""
+        LOGGER.info('delete_state called with key:%s' % key)
+        # Access public data by setting the collection to empty string
+        collection = ''
+        return await self.client.handle_delete_state(collection, key, self.channel_id, self.tx_id)
+
+    async def get_state_by_range(self, start_key: str, end_key: str):
+        """Returns a range of keys from the ledger.
+
+        Returns an async iterator yielding :class:`KV` records (with
+        ``key`` and ``value`` byte fields).  Both keys may be empty strings
+        to mean "unbounded".
+        """
+        collection = ''
+        from src.fabric_shim.iterators import StateQueryIterator
+        from fabric_protos.peer import chaincode_shim_pb2 as ccshim_pb2
+        from fabric_protos.ledger.queryresult import kv_query_result_pb2 as kv_pb
+
+        raw = await self.client.handle_get_state_by_range(
+            collection, start_key, end_key,
+            self.channel_id, self.tx_id,
+        )
+        return StateQueryIterator(
+            handler=self.client,
+            channel_id=self.channel_id,
+            tx_id=self.tx_id,
+            initial_response=raw,
+            response_factory=lambda payload: ccshim_pb2.QueryResponse.FromString(payload),
+            parser=lambda qrb: kv_pb.KV.FromString(qrb.resultBytes),
+        )
+
+    async def get_state_by_range_with_pagination(self, start_key: str, end_key: str,
+                                                   page_size: int, bookmark: str = ""):
+        """Paginated version of :meth:`get_state_by_range`.
+
+        Returns an async iterator yielding :class:`KV` records.  Use the
+        :meth:`aclose` method of the iterator when you want to stop early.
+        """
+        collection = ''
+        from src.fabric_shim.iterators import StateQueryIterator
+        from fabric_protos.peer import chaincode_shim_pb2 as ccshim_pb2
+        from fabric_protos.ledger.queryresult import kv_query_result_pb2 as kv_pb
+
+        meta = ccshim_pb2.QueryMetadata()
+        meta.pageSize = int(page_size)
+        meta.bookmark = bookmark or ""
+        raw = await self.client.handle_get_state_by_range(
+            collection, start_key, end_key,
+            self.channel_id, self.tx_id, metadata=meta.SerializeToString(),
+        )
+        return StateQueryIterator(
+            handler=self.client,
+            channel_id=self.channel_id,
+            tx_id=self.tx_id,
+            initial_response=raw,
+            response_factory=lambda payload: ccshim_pb2.QueryResponse.FromString(payload),
+            parser=lambda qrb: kv_pb.KV.FromString(qrb.resultBytes),
+        )
+
+    async def get_query_result(self, query: str):
+        """Run a CouchDB rich query against the world state.
+
+        Returns an async iterator yielding :class:`KV` records.
+        """
+        collection = ''
+        from src.fabric_shim.iterators import QueryResultIterator
+        from fabric_protos.peer import chaincode_shim_pb2 as ccshim_pb2
+        from fabric_protos.ledger.queryresult import kv_query_result_pb2 as kv_pb
+
+        raw = await self.client.handle_get_query_result(
+            collection, query, self.channel_id, self.tx_id,
+        )
+        return QueryResultIterator(
+            handler=self.client,
+            channel_id=self.channel_id,
+            tx_id=self.tx_id,
+            initial_response=raw,
+            response_factory=lambda payload: ccshim_pb2.QueryResponse.FromString(payload),
+            parser=lambda qrb: kv_pb.KV.FromString(qrb.resultBytes),
+        )
+
+    async def get_query_result_with_pagination(self, query: str, page_size: int,
+                                                bookmark: str = ""):
+        """Paginated version of :meth:`get_query_result`."""
+        collection = ''
+        from src.fabric_shim.iterators import QueryResultIterator
+        from fabric_protos.peer import chaincode_shim_pb2 as ccshim_pb2
+        from fabric_protos.ledger.queryresult import kv_query_result_pb2 as kv_pb
+
+        meta = ccshim_pb2.QueryMetadata()
+        meta.pageSize = int(page_size)
+        meta.bookmark = bookmark or ""
+        raw = await self.client.handle_get_query_result(
+            collection, query, self.channel_id, self.tx_id,
+            metadata=meta.SerializeToString(),
+        )
+        return QueryResultIterator(
+            handler=self.client,
+            channel_id=self.channel_id,
+            tx_id=self.tx_id,
+            initial_response=raw,
+            response_factory=lambda payload: ccshim_pb2.QueryResponse.FromString(payload),
+            parser=lambda qrb: kv_pb.KV.FromString(qrb.resultBytes),
+        )
+
+    async def get_history_for_key(self, key: str):
+        """Return the history of modifications for *key*.
+
+        Yields :class:`KeyModification` records (``tx_id``, ``value``,
+        ``timestamp``, ``is_delete``).
+        """
+        from src.fabric_shim.iterators import HistoryQueryIterator
+        from fabric_protos.peer import chaincode_shim_pb2 as ccshim_pb2
+        from fabric_protos.ledger.queryresult import kv_query_result_pb2 as kv_pb
+
+        raw = await self.client.handle_get_history_for_key(
+            key, self.channel_id, self.tx_id,
+        )
+        return HistoryQueryIterator(
+            handler=self.client,
+            channel_id=self.channel_id,
+            tx_id=self.tx_id,
+            initial_response=raw,
+            response_factory=lambda payload: ccshim_pb2.QueryResponse.FromString(payload),
+            parser=lambda qrb: kv_pb.KeyModification.FromString(qrb.resultBytes),
+        )
+
+    async def get_state_by_partial_composite_key(self, object_type: str,
+                                                   attributes):
+        """Range query on the ledger using a partial composite key.
+
+        Builds a composite key prefix from *object_type* and *attributes*
+        and runs a range query from that prefix to the next code point.
+        """
+        full_key = self.create_composite_key(object_type, attributes)
+        # Range from the composite key to the same prefix with the maximum
+        # rune appended — this is the Fabric convention for "prefix" range
+        # queries against composite keys.
+        end_key = full_key + '\U0010FFFF'
+        return await self.get_state_by_range(full_key, end_key)
+
+    async def invoke_chaincode(self, chaincode_name: str, args, channel: str = ""):
+        """Invoke another chaincode by name.
+
+        ``args`` is a list of strings (or bytes).  The return value is the
+        ``Response`` produced by the invoked chaincode.
+        """
+        from fabric_protos.peer import proposal_response_pb2 as pr_pb
+        # If a channel is supplied, build a fully-qualified name.
+        fully_qualified = f"{chaincode_name}/{channel}" if channel else chaincode_name
+        raw = await self.client.handle_invoke_chaincode(
+            fully_qualified, list(args), self.channel_id, self.tx_id,
+        )
+        # raw.payload is a serialised proposal Response
+        return pr_pb.Response.FromString(raw.payload)
+
+    def set_event(self, name: str, payload):
+        """Emit a chaincode event.
+
+        ``payload`` is stored on the stub and serialised into the final
+        ``COMPLETED`` message built by the handler.
+        """
+        if not isinstance(name, str) or not name:
+            raise Exception('event name must be a non-empty string')
+        if isinstance(payload, str):
+            payload = payload.encode()
+        elif payload is None:
+            payload = b''
+        # Lazily initialise the event list on the stub.
+        if not hasattr(self, '_events') or self._events is None:
+            self._events = []
+        from fabric_protos.peer import chaincode_event_pb2 as e_pb
+        evt = e_pb.ChaincodeEvent()
+        evt.chaincode_id = self.chaincode_id_name if hasattr(self, 'chaincode_id_name') else ""
+        evt.tx_id = self.tx_id
+        evt.event_name = name
+        evt.payload = bytes(payload)
+        self._events.append(evt)
+
+    def get_events(self):
+        """Internal: return the list of accumulated events (used by handler)."""
+        return list(getattr(self, '_events', []) or [])
+
+    def create_composite_key(self, object_type, attributes):
+        """Creates a composite key by combining the objectType string
+        and the given `attributes` to form a composite key"""
+        validate_composite_key_attribute(object_type)
+        if not isinstance(attributes, Sequence):
+            raise Exception('attributes must be an array')
+
+        composite_key = COMPOSITEKEY_NS + object_type + MIN_UNICODE_RUNE_VALUE
+        for attribute in attributes:
+            validate_composite_key_attribute(attribute)
+            composite_key = composite_key + attribute + MIN_UNICODE_RUNE_VALUE
+        return composite_key
+
+    def split_composite_key(self, composite_key):
+        object_type = None
+        attributes = []
+        if composite_key and len(composite_key) > 1 and composite_key[0] == COMPOSITEKEY_NS:
+            split_key = composite_key[1:].split(MIN_UNICODE_RUNE_VALUE)
+            object_type = split_key[0]
+            split_key.pop()
+            if len(split_key) > 1:
+                split_key.pop(0)
+                attributes = split_key
+        return object_type, attributes

src/fabric_shim/utils.py

@@ -0,0 +1,41 @@
+# SPDX-License-Identifier: Apache-2.0
+# Auxiliary tools
+
+
+def enum_type(*sequential, **named) -> type:
+    """enum other than class Enum. better performance
+
+    Typical usage example:
+        >> Numbers = enum('ZERO', 'ONE', 'TWO')
+        >> Numbers.ZERO
+        0
+    or:
+        >> Numbers = enum_type(ONE=1, TWO=2, THREE='three')
+        >> Numbers.THREE
+        'three'
+    Args:
+        sequential: Collects all the positional arguments in a tuple.
+        named: Collects all the keyword arguments in a dictionary.
+
+    """
+    enums = dict(zip(sequential, range(len(sequential))), **named)
+    return type('Enum', (), enums)
+
+
+MIN_UNICODE_RUNE_VALUE = '\u0000'
+COMPOSITEKEY_NS = '\x00'
+
+
+def validate_composite_key_attribute(attr):
+    if attr is None or not isinstance(attr, str) or len(attr) == 0:
+        raise Exception('object type or attribute not a non-zero length string')
+
+
+def validate_simple_keys(keys):
+    for key in keys:
+        if key and isinstance(key, str) and key[0] == COMPOSITEKEY_NS:
+            raise Exception('first character of the key %s contains a null character which is not allowed' % key)
+
+
+def generate_logging_prefix(channel_id, tx_id):
+    return '[%s-%s]' % (channel_id, tx_id)

src/version.py

@@ -0,0 +1,3 @@
+# SPDX-License-Identifier: Apache-2.0
+
+VERSION = "0.9.0"