Merge branch 'main' into feat/apple-silicon-support - Resolve conflicts and integrate latest changes

Author: Vishvendra

src/api-engine/api/lib/agent/docker/handler.py

@@ -56,6 +56,7 @@ def create(self, info):
             else:
                 return None
         except Exception as e:
+            LOG.exception("DockerAgent Not Created")
             raise e
 
     def delete(self, *args, **kwargs):
@@ -66,6 +67,7 @@ def delete(self, *args, **kwargs):
             else:
                 raise response.reason
         except Exception as e:
+            LOG.exception("DockerAgent Not Deleted")
             raise e
 
     def start(self, *args, **kwargs):
@@ -76,6 +78,7 @@ def start(self, *args, **kwargs):
             else:
                 raise response.reason
         except Exception as e:
+            LOG.exception("DockerAgent Not Started")
             raise e
 
     def restart(self, *args, **kwargs):
@@ -86,6 +89,7 @@ def restart(self, *args, **kwargs):
             else:
                 raise response.reason
         except Exception as e:
+            LOG.exception("DockerAgent Not Restarted")
             raise e
 
     def stop(self, *args, **kwargs):
@@ -96,6 +100,7 @@ def stop(self, *args, **kwargs):
             else:
                 raise response.reason
         except Exception as e:
+            LOG.exception("DockerAgent Not Stopped")
             raise e
 
     def get(self, *args, **kwargs):
@@ -106,6 +111,7 @@ def get(self, *args, **kwargs):
             else:
                 raise response.reason
         except Exception as e:
+            LOG.exception("DockerAgent Not Found")
             raise e
 
     def update_config(self, config_file, node_type):
@@ -123,4 +129,5 @@ def update_config(self, config_file, node_type):
             else:
                 raise response.reason
         except Exception as e:
+            LOG.exception("Config Update Failed")
             raise e

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

@@ -119,7 +119,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
@@ -216,96 +215,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
 
@@ -321,10 +337,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/agent/views.py

@@ -205,7 +205,7 @@ def retrieve(self, request, pk=None):
             if agent.type == HostType.Kubernetes.name.lower():
                 k8s_config = KubernetesConfig.objects.get(agent=agent)
         except ObjectDoesNotExist:
-            raise ResourceNotFound
+            raise ResourceNotFound("Agent not found")
         else:
             data = agent.__dict__
             if k8s_config:
@@ -234,7 +234,7 @@ def update(self, request, pk=None):
                 # organization = request.user.organization
                 try:
                     if Agent.objects.get(name=name):
-                        raise ResourceExists
+                        raise ResourceExists("Agent Exists")
                 except ObjectDoesNotExist:
                     pass
                 Agent.objects.filter(id=pk).update(name=name)
@@ -266,7 +266,7 @@ def partial_update(self, request, pk=None):
                 try:
                     agent = Agent.objects.get(id=pk)
                 except ObjectDoesNotExist:
-                    raise ResourceNotFound
+                    raise ResourceNotFound("Agent not found")
                 else:
                     if name:
                         agent.name = name
@@ -308,10 +308,10 @@ def destroy(self, request, pk=None):
                 else:
                     raise CustomError("User can't delete agent！")
             except ObjectDoesNotExist:
-                raise ResourceNotFound
+                raise ResourceNotFound("Agent not found")
             else:
                 if agent.node.count():
-                    raise ResourceInUse
+                    raise ResourceInUse("Agent in use")
                 agent.delete()
 
                 return Response(ok(None), status=status.HTTP_202_ACCEPTED)
@@ -357,7 +357,7 @@ def apply(self, request):
                     schedulable=True,
                 ).order_by("capacity")
                 if len(agents) == 0:
-                    raise NoResource
+                    raise NoResource("No Agent")
 
                 agent = agents[0]
                 agent.organization = request.user.organization
@@ -371,6 +371,7 @@ def apply(self, request):
         except NoResource as e:
             raise e
         except Exception as e:
+            LOG.exception("Agent Not Applied")
             return Response(
                 err(e.args), status=status.HTTP_400_BAD_REQUEST
             )
@@ -399,7 +400,7 @@ def release(self, request, pk=None):
                         id=pk, organization=request.user.organization
                     )
             except ObjectDoesNotExist:
-                raise ResourceNotFound
+                raise ResourceNotFound("Agent not found")
             else:
                 agent.organization = None
                 agent.save()