Merge pull request #688 from YoungHypo/issue-commit-backend

Enhance backend support for chaincode commit

Author: yeasy

src/api-engine/api/lib/peer/chaincode.py

@@ -118,7 +118,6 @@ def lifecycle_approve_for_my_org(self, orderer_url, channel_name, cc_name,
         The administrator can use the peer lifecycle chaincode approveformyorg subcommand to approve the chain code on
         behalf of the organization.
         :param orderer_url: orderer accessable url
-        :param orderer_tls_rootcert: orderer tls certificate
         :param channel_name: channel name
         :param cc_name: chaincode name
         :param chaincode_version: chaincode version
@@ -215,96 +214,113 @@ def lifecycle_query_approved(self, channel_name, cc_name):
 
         return return_code, chaincodes_info
 
-    def lifecycle_check_commit_readiness(self, orderer_url, orderer_tls_rootcert, channel_name, cc_name, cc_version,
-                                         policy, sequence=1):
+    def lifecycle_check_commit_readiness(self, channel_name, cc_name, cc_version, sequence=1):
         """
-
-        :param orderer_url:orderer accessable url
-        :param orderer_tls_rootcert:orderer tls certificate
         :param channel_name:channel name
         :param cc_name: chaincode name
         :param cc_version: chaincode version
-        :param policy:chaincode policy
         :param sequence:The channel chain code defines the serial number. The default value is 1
         :return:
         """
         try:
+            ORDERER_CA = os.getenv("ORDERER_CA")
+            command = []
             if os.getenv("CORE_PEER_TLS_ENABLED") == "false" or os.getenv("CORE_PEER_TLS_ENABLED") is None:
-                res = subprocess.Popen("{} lifecycle chaincode checkcommitreadiness --output json "
-                                       " --channelID {}  --name {} --version {} --init-required --sequence {} "
-                                       "--signature-policy {}"
-                                       .format(self.peer, channel_name, cc_name, cc_version, sequence, policy),
-                                       shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-                stdout, stderr = res.communicate()
-                return_code = res.returncode
-                if return_code == 0:
-                    content = str(stdout, encoding="utf-8")
-                    chaincodes_info = json.loads(content)
-                    return return_code, chaincodes_info
-                else:
-                    stderr = str(stderr, encoding="utf-8")
-                    return return_code, stderr
+                command = [
+                    self.peer,
+                    "lifecycle", "chaincode", "checkcommitreadiness",
+                    "--channelID", channel_name,
+                    "--name", cc_name,
+                    "--version", cc_version,
+                    "--sequence", str(sequence),
+                    "--output", "json",
+                ]
             else:
-                res = subprocess.Popen("{} lifecycle chaincode checkcommitreadiness --output json "
-                                       "-o {} --tls --cafile {} --channelID {}  --name {} --version {} "
-                                       "--signature-policy {} --init-required --sequence {}"
-                                       .format(self.peer, orderer_url, orderer_tls_rootcert, channel_name, cc_name,
-                                               cc_version, policy, sequence),
-                                       shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-                stdout, stderr = res.communicate()
-                return_code = res.returncode
-                if return_code == 0:
-                    content = str(stdout, encoding="utf-8")
-                    chaincodes_info = json.loads(content)
-                    return return_code, chaincodes_info
-                else:
-                    stderr = str(stderr, encoding="utf-8")
-                    return return_code, stderr
+                command = [
+                    self.peer,
+                    "lifecycle", "chaincode", "checkcommitreadiness",
+                    "--channelID", channel_name,
+                    "--name", cc_name,
+                    "--version", cc_version,
+                    "--sequence", str(sequence),
+                    "--tls",
+                    "--cafile", ORDERER_CA,
+                    "--output", "json",
+                ]
+            
+            LOG.info(" ".join(command))
+
+            res = subprocess.Popen(command, shell=False,
+                                   stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            stdout, stderr = res.communicate()
+            return_code = res.returncode
+            if return_code == 0:
+                content = str(stdout, encoding="utf-8")
+                chaincodes_info = json.loads(content)
+                return return_code, chaincodes_info
+            else:
+                stderr = str(stderr, encoding="utf-8")
+                return return_code, stderr
         except Exception as e:
-            err_msg = "lifecycle_check_commit_readiness failed for {}!".format(
-                e)
+            err_msg = "lifecycle_check_commit_readiness failed for {}!".format(e)
             raise Exception(err_msg)
 
-    def lifecycle_commit(self, orderer_url, orderer_tls_rootcert, channel_name, cc_name, chaincode_version,
-                         policy, peerlist, peer_root_certs, sequency=1):
+    def lifecycle_commit(self, orderer_url, channel_name, cc_name, chaincode_version, sequence, policy, peer_list=[], peer_root_certs=[], init_flag=False):
         """
         The administrator can submit the chain code definition to the specified channel by using the peer lifecycle
         chain code commit subcommand
         :param orderer_url: orderer accessable url
-        :param orderer_tls_rootcert:orderer tls certificate
         :param channel_name:channel name
         :param cc_name:chaincode name
         :param chaincode_version:chaincode version
+        :param sequence:The channel chain code defines the serial number. The default value is 1
         :param policy:chaincode policy
-        :param peerlist: the list of peerAddress
+        :param peer_list: the list of peerAddress
         :param peer_root_certs: the list of peer_root_certs, the orderer should be same as peerlist's.
-        :param sequency:The channel chain code defines the serial number. The default value is 1
+        :param init_flag:if the chaincode is first init.
         :return:
         """
         try:
-            peer_addresses_format = " --peerAddresses {} --tlsRootCertFiles {}"
-            command_str_with_tls = "{} lifecycle chaincode commit -o {} --tls --cafile {} " \
-                                   "--channelID {} --name {} --version {} --init-required --sequence {} " \
-                                   "--signature-policy {}"
-            command_str_without_tls = "{} lifecycle chaincode commit -o {} --channelID {} --name {} " \
-                                      "--version {} --init-required --sequence {} --signature-policy {}"
-
-            peer_addressed = []
-            for i in range(len(peerlist)):
-                peer_addressed.append(peerlist[i])
-                peer_addressed.append(peer_root_certs[i])
+            command = []
             if os.getenv("CORE_PEER_TLS_ENABLED") == "false" or os.getenv("CORE_PEER_TLS_ENABLED") is None:
-                for i in range(len(peerlist)):
-                    command_str_without_tls = command_str_without_tls + peer_addresses_format
-                res = os.system(command_str_without_tls.format(self.peer, orderer_url, channel_name, cc_name,
-                                chaincode_version, sequency, policy, *peer_addressed))      # --collections-config {}
+                command = [
+                    self.peer,
+                    "lifecycle", "chaincode", "commit",
+                    "-o", orderer_url,
+                    "--channelID", channel_name,
+                    "--name", cc_name,
+                    "--version", chaincode_version,
+                    "--sequence", str(sequence),
+                ]
             else:
-                for i in range(len(peerlist)):
-                    command_str_with_tls = command_str_with_tls + peer_addresses_format
-
-                res = os.system(command_str_with_tls.format(self.peer, orderer_url, orderer_tls_rootcert, channel_name,
-                                cc_name, chaincode_version, sequency, policy, *peer_addressed))
+                ORDERER_CA = os.getenv("ORDERER_CA")
+                command = [
+                    self.peer,
+                    "lifecycle", "chaincode", "commit",
+                    "-o", orderer_url,
+                    "--ordererTLSHostnameOverride", orderer_url.split(":")[0],
+                    "--channelID", channel_name,
+                    "--name", cc_name,
+                    "--version", chaincode_version,
+                    "--sequence", str(sequence),
+                    "--tls",
+                    "--cafile", ORDERER_CA,
+                ]
 
+            for i in range(len(peer_list)):
+                command.append("--peerAddresses")
+                command.append(peer_list[i])
+                command.append("--tlsRootCertFiles")
+                command.append(peer_root_certs[i])
+            
+            if init_flag:
+                command.append("--init-required")
+            if policy:
+                command.append("--signature-policy")
+                command.append(policy)
+            
+            LOG.info(" ".join(command))
+            res = os.system(" ".join(command))
             res = res >> 8
             return res
 
@@ -320,10 +336,16 @@ def lifecycle_query_committed(self, channel_name, cc_name):
         :return: chaincodes info has commited in channel of the cc_name
         """
         try:
-            res = subprocess.Popen("{} lifecycle chaincode querycommitted --channelID {} "
-                                   "--output json --name {}".format(
-                                       self.peer, channel_name, cc_name),
-                                   shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            command = [
+                self.peer,
+                "lifecycle", "chaincode", "querycommitted",
+                "--channelID", channel_name,
+                "--output", "json",
+                "--name", cc_name,
+            ]
+            LOG.info(" ".join(command))
+            res = subprocess.Popen(command, shell=False,
+                                   stdout=subprocess.PIPE, stderr=subprocess.PIPE)
             stdout, stderr = res.communicate()
             return_code = res.returncode
             if return_code == 0:

src/api-engine/api/routes/chaincode/serializers.py

@@ -68,4 +68,4 @@ class ChainCodeApproveForMyOrgBody(serializers.Serializer):
 
 
 class ChainCodeCommitBody(ChainCodeApproveForMyOrgBody):
-    peer_list = serializers.ListField(allow_empty=False, required=True)
+    pass

src/api-engine/api/routes/chaincode/views.py

@@ -16,7 +16,8 @@
 from api.config import CELLO_HOME
 from api.models import (
     Node,
-    ChainCode
+    ChainCode,
+    Channel
 )
 from api.utils.common import make_uuid
 from django.core.paginator import Paginator
@@ -495,61 +496,114 @@ def commit(self, request):
             try:
                 channel_name = serializer.validated_data.get("channel_name")
                 chaincode_name = serializer.validated_data.get("chaincode_name")
-                chaincode_version = serializer.validated_data.get(
-                    "chaincode_version")
+                chaincode_version = serializer.validated_data.get("chaincode_version")
                 policy = serializer.validated_data.get("policy")
-                # Perhaps the orderer's port is best stored in the database
-                orderer_url = serializer.validated_data.get("orderer_url")
                 sequence = serializer.validated_data.get("sequence")
-                peer_list = serializer.validated_data.get("peer_list")
+                init_flag = serializer.validated_data.get("init_flag", False)
+                
                 org = request.user.organization
                 qs = Node.objects.filter(type="orderer", organization=org)
                 if not qs.exists():
                     raise ResourceNotFound("Orderer Does Not Exist")
                 orderer_node = qs.first()
+                orderer_url = orderer_node.name + "." + org.name.split(".", 1)[1] + ":" + str(7050)
 
-                orderer_tls_dir = "{}/{}/crypto-config/ordererOrganizations/{}/orderers/{}/msp/tlscacerts" \
-                    .format(CELLO_HOME, org.name, org.name.split(".", 1)[1], orderer_node.name + "." +
-                            org.name.split(".", 1)[1])
-                orderer_tls_root_cert = ""
-                for _, _, files in os.walk(orderer_tls_dir):
-                    orderer_tls_root_cert = orderer_tls_dir + "/" + files[0]
-                    break
-
+                # Step 1: Check commit readiness, find all approved organizations
                 qs = Node.objects.filter(type="peer", organization=org)
                 if not qs.exists():
                     raise ResourceNotFound("Peer Does Not Exist")
                 peer_node = qs.first()
                 envs = init_env_vars(peer_node, org)
-
-                peer_root_certs = []
+                
+                peer_channel_cli = PeerChainCode(**envs)
+                code, readiness_result = peer_channel_cli.lifecycle_check_commit_readiness(
+                    channel_name, chaincode_name, chaincode_version, sequence)
+                if code != 0:
+                    return Response(err(f"Check commit readiness failed: {readiness_result}"), 
+                                  status=status.HTTP_400_BAD_REQUEST)
+                
+                # Check approved status
+                approvals = readiness_result.get("approvals", {})
+                approved_orgs = [org_msp for org_msp, approved in approvals.items() if approved]
+                if not approved_orgs:
+                    return Response(err("No organizations have approved this chaincode"), 
+                                  status=status.HTTP_400_BAD_REQUEST)
+                
+                LOG.info(f"Approved organizations: {approved_orgs}")
+
+                # Step 2: Get channel organizations and peer nodes
+                try:
+                    channel = Channel.objects.get(name=channel_name)
+                    channel_orgs = channel.organizations.all()
+                except Channel.DoesNotExist:
+                    return Response(err(f"Channel {channel_name} not found"), 
+                                  status=status.HTTP_400_BAD_REQUEST)
+
+                # find the corresponding organization by MSP ID
+                # MSP ID format: Org1MSP, Org2MSP -> organization name format: org1.xxx, org2.xxx
+                approved_organizations = []
+                for msp_id in approved_orgs:
+                    if msp_id.endswith("MSP"):
+                        org_prefix = msp_id[:-3].lower()  # remove "MSP" and convert to lowercase
+                        # find the corresponding organization in the channel
+                        for channel_org in channel_orgs:
+                            if channel_org.name.split(".")[0] == org_prefix:
+                                approved_organizations.append(channel_org)
+                                LOG.info(f"Found approved organization: {channel_org.name} (MSP: {msp_id})")
+                                break
+
+                if not approved_organizations:
+                    return Response(err("No approved organizations found in this channel"), 
+                                  status=status.HTTP_400_BAD_REQUEST)
+
+                # get peer nodes and root certs
                 peer_address_list = []
-                for each in peer_list:
-                    peer_node = Node.objects.get(id=each)
-                    peer_tls_cert = "{}/{}/crypto-config/peerOrganizations/{}/peers/{}/tls/ca.crt" \
-                                    .format(CELLO_HOME, org.name, org.name, peer_node.name + "." + org.name)
-                    print(peer_node.port)
-                    # port = peer_node.port.all()[0].internal
-                    # port = ports[0].internal
-                    peer_address = peer_node.name + \
-                        "." + org.name + ":" + str(7051)
-                    peer_address_list.append(peer_address)
-                    peer_root_certs.append(peer_tls_cert)
+                peer_root_certs = []
+                
+                for approved_org in approved_organizations:
+                    org_peer_nodes = Node.objects.filter(type="peer", organization=approved_org)
+                    if org_peer_nodes.exists():
+                        # select the first peer node for each organization
+                        peer = org_peer_nodes.first()
+                        peer_tls_cert = "{}/{}/crypto-config/peerOrganizations/{}/peers/{}/tls/ca.crt" \
+                                        .format(CELLO_HOME, approved_org.name, approved_org.name, 
+                                               peer.name + "." + approved_org.name)
+                        peer_address = peer.name + "." + approved_org.name + ":" + str(7051)
+                        peer_address_list.append(peer_address)
+                        peer_root_certs.append(peer_tls_cert)
+                        LOG.info(f"Added peer from approved org {approved_org.name}: {peer_address}")
+                    else:
+                        LOG.warning(f"No peer nodes found for approved organization: {approved_org.name}")
 
-                peer_channel_cli = PeerChainCode(**envs)
-                code = peer_channel_cli.lifecycle_commit(orderer_url, orderer_tls_root_cert, channel_name,
-                                                         chaincode_name, chaincode_version, policy,
-                                                         peer_address_list, peer_root_certs, sequence)
+                if not peer_address_list:
+                    return Response(err("No peer nodes found for approved organizations"), 
+                                  status=status.HTTP_400_BAD_REQUEST)
+
+                # Step 3: Commit chaincode
+                code = peer_channel_cli.lifecycle_commit(
+                    orderer_url, channel_name, chaincode_name, chaincode_version, 
+                    sequence, policy, peer_address_list, peer_root_certs, init_flag)
                 if code != 0:
-                    return Response(err("commit failed."), status=status.HTTP_400_BAD_REQUEST)
+                    return Response(err("Commit chaincode failed"), 
+                                  status=status.HTTP_400_BAD_REQUEST)
+
+                LOG.info(f"Chaincode {chaincode_name} committed successfully")
+
+                # Step 4: Query committed chaincode
+                code, committed_result = peer_channel_cli.lifecycle_query_committed(
+                    channel_name, chaincode_name)
+                if code == 0:
+                    LOG.info(committed_result)
+                    return Response(ok(committed_result), status=status.HTTP_200_OK)
+                else:
+                    return Response(err("Query committed failed."), status=status.HTTP_400_BAD_REQUEST)
 
             except Exception as e:
+                LOG.error(f"Commit chaincode failed: {str(e)}")
                 return Response(
-                    err(e.args), status=status.HTTP_400_BAD_REQUEST
+                    err(f"Commit chaincode failed: {str(e)}"), 
+                    status=status.HTTP_400_BAD_REQUEST
                 )
-            return Response(
-                ok("commit success."), status=status.HTTP_200_OK
-            )
 
     @swagger_auto_schema(
         method="get",