Merge branch 'Develop' into Feature/CQC_conditionals

Author: VictorPrins

.bumpversion.cfg

@@ -0,0 +1,9 @@
+[bumpversion]
+current_version = 3.0.4
+commit = True
+tag = False
+
+[bumpversion:file:cqc/__init__.py]
+
+[bumpversion:file:README.md]
+

CHANGELOG.md

@@ -6,6 +6,14 @@ For more details refer to the [documentation](https://softwarequtech.github.io/S
 Upcoming
 --------
 
+2019-10-16 (v3.0.4)
+-------------------
+- If a CQCConnection does not manage to connect to the cqc server, the used app ID is popped from the list of used ones, to be reused again.
+
+2019-10-08 (v3.0.3)
+-------------------
+- Fixed bug that mixes up return messages for different application IDs
+
 2019-05-29 (v3.0.2)
 -------------------
 - Updated coinflip example and added CI.

README.md

@@ -1,3 +1,5 @@
+# CQC (3.0.4)
+
 The classical-quantum combiner (CQC) interface is an interface between higher layers and hardware in a Quantum Internet. It comes with a Python, C and Rust library for constructing CQC messages. The Python library is definitely the best place to get started.
 
 Documentation of CQC can be found at https://softwarequtech.github.io/SimulaQron/html/CQCInterface.html

cqc/MessageHandler.py

@@ -26,9 +26,9 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-from abc import ABC, abstractmethod
-from collections import defaultdict
 import logging
+from collections import defaultdict
+from abc import ABC, abstractmethod
 
 from cqc.cqcHeader import (
     CQCCmdHeader,
@@ -178,6 +178,7 @@ def __init__(self, factory):
 
         # Convenience
         self.name = factory.name
+        self.return_messages = defaultdict(list)  # Dictionary of all cqc messages to return per app_id
 
         # List of all cqc messages to return
         self.return_messages = []  
@@ -191,38 +192,38 @@ def handle_cqc_message(self, header, message, transport=None):
         """
         This calls the correct method to handle the cqcmessage, based on the type specified in the header
         """
-        self.return_messages = []
-
+        self.return_messages[header.app_id] = []
         if header.tp in self.messageHandlers:
             try:
                 should_notify = yield self.messageHandlers[header.tp](header, message)
 
                 if should_notify:
                     # Send a notification that we are done if successful
                     logging.debug("CQC %s: Command successful, sent done.", self.name)
-                    self.return_messages.append(
+                    self.return_messages[header.app_id].append(
                         self.create_return_message(header.app_id, CQC_TP_DONE, cqc_version=header.version))
             except UnknownQubitError:
                 logging.error("CQC {}: Couldn't find qubit with given ID".format(self.name))
-                self.return_messages.append(
+                self.return_messages[header.app_id].append(
                     self.create_return_message(header.app_id, CQC_ERR_UNKNOWN, cqc_version=header.version))
             except NotImplementedError:
                 logging.error("CQC {}: Command not implemented yet".format(self.name))
-                self.return_messages.append(
+                self.return_messages[header.app_id].append(
                     self.create_return_message(header.app_id, CQC_ERR_UNSUPP, cqc_version=header.version))
             except Exception as err:
                 logging.error(
                     "CQC {}: Got the following unexpected error when handling CQC message: {}".format(self.name, err)
                 )
-                self.return_messages.append(
+                self.return_messages[header.app_id].append(
                     self.create_return_message(header.app_id, CQC_ERR_GENERAL, cqc_version=header.version))
         else:
             logging.error("CQC %s: Could not find cqc type %d in handlers.", self.name, header.yp)
-            self.return_messages.append(
+            self.return_messages[header.app_id].append(
                 self.create_return_message(header.app_id, CQC_ERR_UNSUPP, cqc_version=header.version))
 
-    def retrieve_return_messages(self):
-        return self.return_messages
+    def retrieve_return_messages(self, app_id):
+        """Retrieve the return messages of a given app_id"""
+        return self.return_messages[app_id]
 
     @staticmethod
     def create_return_message(app_id, msg_type, length=0, cqc_version=CQC_VERSION):
@@ -315,13 +316,13 @@ def _process_command(self, cqc_header, length, data, is_locked=False):
             if cmd.instr not in self.commandHandlers:
                 logging.debug("CQC {}: Unknown command {}".format(self.name, cmd.instr))
                 msg = self.create_return_message(cqc_header.app_id, CQC_ERR_UNSUPP, cqc_version=cqc_header.version)
-                self.return_messages.append(msg)
+                self.return_messages[cqc_header.app_id].append(msg)
                 return False, 0
             try:
                 succ = yield self.commandHandlers[cmd.instr](cqc_header, cmd, xtra)
             except NotImplementedError:
                 logging.error("CQC {}: Command not implemented yet".format(self.name))
-                self.return_messages.append(
+                self.return_messages[cqc_header.app_id].append(
                     self.create_return_message(cqc_header.app_id, CQC_ERR_UNSUPP, cqc_version=cqc_header.verstion))
                 return False, 0
             except Exception as err:
@@ -331,7 +332,7 @@ def _process_command(self, cqc_header, length, data, is_locked=False):
                     )
                 )
                 msg = self.create_return_message(cqc_header.app_id, CQC_ERR_GENERAL, cqc_version=cqc_header.version)
-                self.return_messages.append(msg)
+                self.return_messages[cqc_header.app_id].append(msg)
                 return False, 0
 
             if succ is False:  # only if it explicitly is false, if succ is None then we assume it went fine
@@ -346,7 +347,7 @@ def handle_factory(self, header, data):
         # Get factory header
         if len(data) < header.length:
             logging.debug("CQC %s: Missing header(s) in factory", self.name)
-            self.return_messages.append(
+            self.return_messages[header.app_id].append(
                 self.create_return_message(header.app_id, CQC_ERR_UNSUPP, cqc_version=header.version))
             return False
         fact_header = CQCFactoryHeader(data[:fact_l])
@@ -369,7 +370,7 @@ def handle_factory(self, header, data):
                 logging.error(
                     "CQC {}: Got the following unexpected error when processing factory: {}".format(self.name, err)
                 )
-                self.return_messages.append(
+                self.return_messages[header.app_id].append(
                     self.create_return_message(header.app_id, CQC_ERR_GENERAL, cqc_version=header.version))
                 return False
 

cqc/Protocol.py

@@ -153,7 +153,7 @@ def dataReceived(self, data):
     def _parseData(self, header, data):
         try:
             yield self.messageHandler.handle_cqc_message(header, data)
-            messages = self.messageHandler.retrieve_return_messages()
+            messages = self.messageHandler.retrieve_return_messages(header.app_id)
         except Exception as e:
             raise e
 

cqc/__init__.py

@@ -1 +1 @@
-__version__ = '3.0.2'
+__version__ = '3.0.4'

cqc/pythonLib.py

@@ -251,7 +251,7 @@ def __init__(self, name, socket_address=None, appID=None, pend_messages=False,
             self._appID = appID
             self._appIDs[name].append(self._appID)
 
-            # Buffer received data
+        # Buffer received data
         self.buf = None
 
         # ClassicalServer
@@ -310,6 +310,7 @@ def __init__(self, name, socket_address=None, appID=None, pend_messages=False,
                 time.sleep(self._conn_retry_time)
                 self._s.close()
                 if not retry_connection:
+                    self.close(release_qubits=False)
                     raise err
             except Exception as err:
                 logging.warning("App {} : Critical error when connection to CQC server: {}".format(self.name, err))
@@ -369,21 +370,27 @@ def get_appID(self):
 
     def close(self, release_qubits=True):
         """
-        Closes the connection. Releases all qubits
+        Closes the connection. Releases all qubits and remove the app ID from the used app IDs.
         """
         if release_qubits:
             self.release_all_qubits()
         self._s.close()
-        try:
-            self._appIDs[self.name].remove(self._appID)
-        except ValueError:
-            pass  # Already closed
+        self._pop_app_id()
 
         self.closeClassicalServer()
 
         for name in list(self._classicalConn):
             self.closeClassicalChannel(name)
 
+    def _pop_app_id(self):
+        """
+        Removes the used appID from the list.
+        """
+        try:
+            self._appIDs[self.name].remove(self._appID)
+        except ValueError:
+            pass  # Already removed
+
     def startClassicalServer(self):
         """
         Sets up a server for the application communication, if not already set up.