Merge pull request #671 from YoungHypo/issue-update-chaincode-query

Upgrade Backend of Chaincode Approve

Author: yeasy

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

@@ -63,9 +63,15 @@ def lifecycle_query_installed(self, timeout):
         """
 
         try:
-            res = subprocess.Popen("{} lifecycle chaincode queryinstalled --output json --connTimeout {}"
-                                   .format(self.peer, timeout), shell=True,
-                                   stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            command = [
+                self.peer,
+                "lifecycle", "chaincode", "queryinstalled",
+                "--output", "json",
+                "--connTimeout", timeout
+            ]
+            LOG.info(" ".join(command))
+            res = subprocess.Popen(command, shell=False,
+                                      stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 
             stdout, stderr = res.communicate()
             return_code = res.returncode
@@ -106,8 +112,8 @@ def lifecycle_get_installed_package(self, timeout):
             raise Exception(err_msg)
         return res_return
 
-    def lifecycle_approve_for_my_org(self, orderer_url, orderer_tls_rootcert, channel_name, cc_name,
-                                     chaincode_version, policy, sequence=1):
+    def lifecycle_approve_for_my_org(self, orderer_url, channel_name, cc_name,
+                                     chaincode_version, sequence, policy, init_flag):
         """
         The administrator can use the peer lifecycle chaincode approveformyorg subcommand to approve the chain code on
         behalf of the organization.
@@ -116,8 +122,9 @@ def lifecycle_approve_for_my_org(self, orderer_url, orderer_tls_rootcert, channe
         :param channel_name: channel name
         :param cc_name: chaincode name
         :param chaincode_version: chaincode version
-        :param policy: chaincode policy
         :param sequence: The channel chain code defines the serial number. The default value is 1
+        :param policy: chaincode policy
+        :param init_flag: if the chaincode is first init.
         :return:
         """
         try:
@@ -131,18 +138,43 @@ def lifecycle_approve_for_my_org(self, orderer_url, orderer_tls_rootcert, channe
             if package_id == "":
                 return 1, "not exist the chaincode, please check chaincode_name and chaincode_version"
 
+            command = []
             if os.getenv("CORE_PEER_TLS_ENABLED") == "false" or os.getenv("CORE_PEER_TLS_ENABLED") is None:
-                res = subprocess.Popen("{} lifecycle chaincode approveformyorg -o {} - --channelID {} --name {} "
-                                       "--version {} --init-required --package-id {} --sequence {} --signature-policy {}"
-                                       .format(self.peer, orderer_url, channel_name, cc_name, chaincode_version, package_id,
-                                               sequence, policy), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                command = [
+                    self.peer,
+                    "lifecycle", "chaincode", "approveformyorg",
+                    "-o", orderer_url,
+                    "--channelID", channel_name,
+                    "--name", cc_name,
+                    "--version", chaincode_version,
+                    "--package-id", package_id,
+                    "--sequence", str(sequence)
+                ]
             else:
-                res = subprocess.Popen("{} lifecycle chaincode approveformyorg -o {} --tls --cafile {} --channelID {} "
-                                       "--name {} --version {} --init-required --package-id {} --sequence {} "
-                                       "--signature-policy {}"
-                                       .format(self.peer, orderer_url, orderer_tls_rootcert, channel_name,
-                                               cc_name, chaincode_version, package_id, sequence, policy), shell=True,
-                                       stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                ORDERER_CA = os.getenv("ORDERER_CA")
+                command = [
+                    self.peer,
+                    "lifecycle", "chaincode", "approveformyorg",
+                    "-o", orderer_url,
+                    "--ordererTLSHostnameOverride", orderer_url.split(":")[0],
+                    "--channelID", channel_name,
+                    "--name", cc_name,
+                    "--version", chaincode_version,
+                    "--package-id", package_id,
+                    "--sequence", str(sequence),
+                    "--tls",
+                    "--cafile", ORDERER_CA
+                ]
+            
+            if init_flag:
+                command.append("--init-required")
+            if policy:
+                command.append("--signature-policy")
+                command.append(policy)
+
+            LOG.info(" ".join(command))
+            res = subprocess.Popen(command, shell=False,
+                                   stdout=subprocess.PIPE, stderr=subprocess.PIPE)
             stdout, stderr = res.communicate()
             return_code = res.returncode
 

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

@@ -62,9 +62,9 @@ class ChainCodeApproveForMyOrgBody(serializers.Serializer):
     channel_name = serializers.CharField(max_length=128, required=True)
     chaincode_name = serializers.CharField(max_length=128, required=True)
     chaincode_version = serializers.CharField(max_length=128, required=True)
-    policy = serializers.CharField(max_length=128, required=True)
-    orderer_url = serializers.CharField(max_length=128, required=True)
     sequence = serializers.IntegerField(min_value=1, required=True)
+    policy = serializers.CharField(max_length=128, required=False, allow_blank=True)
+    init_flag = serializers.BooleanField(required=False)
 
 
 class ChainCodeCommitBody(ChainCodeApproveForMyOrgBody):

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

@@ -328,35 +328,27 @@ def approve_for_my_org(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")
-                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")
+                chaincode_version = serializer.validated_data.get("chaincode_version")
+                policy = serializer.validated_data.get("policy", "")
                 sequence = serializer.validated_data.get("sequence")
+                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_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
                 qs = Node.objects.filter(type="peer", organization=org)
                 if not qs.exists():
                     raise ResourceNotFound
                 peer_node = qs.first()
                 envs = init_env_vars(peer_node, org)
 
                 peer_channel_cli = PeerChainCode(**envs)
-                code, content = peer_channel_cli.lifecycle_approve_for_my_org(orderer_url, orderer_tls_root_cert, channel_name,
-                                                                              chaincode_name, chaincode_version, policy, sequence)
+                code, content = peer_channel_cli.lifecycle_approve_for_my_org(orderer_url, channel_name,
+                                                                              chaincode_name, chaincode_version, sequence, policy, init_flag)
                 if code != 0:
                     return Response(err(" lifecycle_approve_for_my_org failed. err: " + content), status=status.HTTP_400_BAD_REQUEST)
             except Exception as e: