Merge pull request #5 from jbaayen/master

MMIClient:  Simplify implementation, implement missing methods, remove s...

Author: SiggyF

mmi/mmi_client.py

@@ -1,151 +1,217 @@
 import zmq
-import logging
 
 from mmi import send_array, recv_array
 from bmi.api import IBmi
 
-logger = logging.getLogger(__name__)
+class MMIClient(IBmi):
+    def __init__(self, zmq_address):
+        """
+        Constructor
+        """
 
+        # Open ZeroMQ socket
+        context = zmq.Context()
 
-class MMIClient(IBmi):
-    def __init__(self, uuid, mmi_metadata):
-        """
-        The 'database' has mmi module metadata.
-
-        the metadata must contain the key "ports"
-        "ports":  {'PUSH': 58452, 'REQ': 53956, 'SUB': 60285}
-        """
-        logger.debug("Initializing MMI Client [%s]..." % uuid)
-        self.uuid = uuid
-        self.database = mmi_metadata
-        self.ports = mmi_metadata['ports']
-
-        self.sockets = {}
-        self.context = zmq.Context()
-
-        logger.debug("Connecting to push/pull server...")
-        if 'PUSH' in self.ports:
-            logger.debug("MMI PUSH is available")
-            self.sockets['PUSH'] = self.context.socket(zmq.PUSH)
-            # TODO: is this correct?
-            url = 'tcp://%s:%d' % (self.database['node'], self.ports['PUSH'])
-            self.sockets['PUSH'].connect(url)
-
-        if 'SUB' in self.ports:
-            logger.debug("MMI SUB is available")
-            self.sockets['SUB'] = self.context.socket(zmq.SUB)
-            url = 'tcp://%s:%d' % (self.database['node'], self.ports['SUB'])
-            self.sockets['SUB'].connect(url)
-
-        if 'REQ' in self.ports:
-            logger.debug("MMI REQ is available")
-            self.sockets['REQ'] = self.context.socket(zmq.REQ)
-            url = 'tcp://%s:%d' % (self.database['node'], self.ports['REQ'])
-            self.sockets['REQ'].connect(url)
-
-    def __getitem__(self, key):
-        """For direct indexing the MMIClient object as a dict"""
-        return self.database[key]
-
-    # from here: BMI commands that gets translated to MMI.
+        self.socket = context.socket(zmq.REQ)
+        self.socket.connect(zmq_address)
+
+    # from here: BMI commands that get translated to MMI.
     def initialize(self, configfile=None):
         """
+        Initialize the module
         """
-        pass
+        
+        method = "initialize"
+        
+        A = None
+        metadata = {method : configfile}
+
+        send_array(self.socket, A, metadata)
+        A, metadata = recv_array(self.socket)
 
     def finalize(self):
         """
+        Finalize the module
         """
-        pass
+        
+        method = "finalize"
+        
+        A = None
+        metadata = {method : -1}
 
-    def update(self, dt=-1):
-        """
-        """
-        metadata = {'update': dt}
-        send_array(self.sockets['REQ'], None, metadata=metadata)
-        arr, result_meta = recv_array(self.sockets['REQ'])
-        return result_meta['dt']
+        send_array(self.socket, A, metadata)
+        A, metadata = recv_array(self.socket)
 
     def get_var_count(self):
         """
+        Return number of variables
         """
-        pass
+
+        method = "get_var_count"
+        
+        A = None
+        metadata = {method : -1}
+
+        send_array(self.socket, A, metadata)
+        A, metadata = recv_array(self.socket)
+
+        return metadata[method]
 
     def get_var_name(self, i):
-        pass
+        """
+        Return variable name
+        """
+
+        method = "get_var_name"
+        
+        A = None
+        metadata = {method : i}
+
+        send_array(self.socket, A, metadata)
+        A, metadata = recv_array(self.socket)
+
+        return metadata[method]
 
     def get_var_type(self, name):
-        metadata = {'get_var_type': name}
-        send_array(self.sockets['REQ'], None, metadata=metadata)
-        arr, result_meta = recv_array(self.sockets['REQ'])
-        return result_meta['get_var_type']
+        """
+        Return variable name
+        """
 
-    def inq_compound(self, name):
-        pass
+        method = "get_var_type"
+        
+        A = None
+        metadata = {method : name}
 
-    def inq_compound_field(self, name, index):
-        pass
+        send_array(self.socket, A, metadata)
+        A, metadata = recv_array(self.socket)
 
-    def make_compound_ctype(self, varname):
-        pass
+        return metadata[method]
 
     def get_var_rank(self, name):
-        metadata = {'get_var_rank': name}
-        send_array(self.sockets['REQ'], None, metadata=metadata)
-        arr, result_meta = recv_array(self.sockets['REQ'])
-        return int(result_meta['get_var_rank'])
+        """
+        Return variable rank
+        """
+
+        method = "get_var_rank"
+        
+        A = None
+        metadata = {method : name}
+
+        send_array(self.socket, A, metadata)
+        A, metadata = recv_array(self.socket)
+
+        return metadata[method]
 
     def get_var_shape(self, name):
-        logger.debug('get_var_shape')
-        metadata = {'get_var_shape': name}
-        send_array(self.sockets['REQ'], None, metadata=metadata)
-        arr, result_meta = recv_array(self.sockets['REQ'])
-        return tuple(result_meta['get_var_shape'])
+        """
+        Return variable shape
+        """
+
+        method = "get_var_shape"
+        
+        A = None
+        metadata = {method : rank}
+
+        send_array(self.socket, A, metadata)
+        A, metadata = recv_array(self.socket)
+
+        return metadata[method]
+
+    def get_var(self, name):
+        """
+        Return an nd array from model library
+        """
+
+        method = "get_var"
+        
+        A = None
+        metadata = {method : name}
+
+        send_array(self.socket, A, metadata)
+        A, metadata = recv_array(self.socket)
+
+        return A
+
+    def set_var(self, name, var):
+        """
+        Set the variable name with the values of var
+        """
+
+        method = "set_var"
+
+        A = var
+        metadata = {method : name}
+
+        send_array(self.socket, A, metadata)
+        A, metadata = recv_array(self.socket)
 
     def get_start_time(self):
-        metadata = {'get_start_time': None}
-        send_array(self.sockets['REQ'], None, metadata=metadata)
-        arr, result_meta = recv_array(self.sockets['REQ'])
-        return float(result_meta['get_start_time'])
+        """
+        Return start time
+        """
+
+        method = "get_start_time"
+        
+        A = None
+        metadata = {method : -1}
+
+        send_array(self.socket, A, metadata)
+        A, metadata = recv_array(self.socket)
+
+        return metadata[method]
 
     def get_end_time(self):
-        metadata = {'get_end_time': None}
-        send_array(self.sockets['REQ'], None, metadata=metadata)
-        arr, result_meta = recv_array(self.sockets['REQ'])
-        return float(result_meta['get_end_time'])
+        """
+        Return end time of simulation
+        """
+
+        method = "get_end_time"
+        
+        A = None
+        metadata = {method : -1}
+
+        send_array(self.socket, A, metadata)
+        A, metadata = recv_array(self.socket)
+
+        return metadata[method]
 
     def get_current_time(self):
-        metadata = {'get_current_time': None}
-        send_array(self.sockets['REQ'], None, metadata=metadata)
-        arr, result_meta = recv_array(self.sockets['REQ'])
-        return float(result_meta['get_current_time'])
+        """
+        Return current time of simulation
+        """
 
-    def get_time_step(self):
-        pass
+        method = "get_current_time"
+        
+        A = None
+        metadata = {method : -1}
 
-    def get_var(self, name):
-        metadata = {'get_var': name}
-        send_array(self.sockets['REQ'], None, metadata=metadata)
-        arr, result_meta = recv_array(self.sockets['REQ'])
-        return arr
+        send_array(self.socket, A, metadata)
+        A, metadata = recv_array(self.socket)
 
-    def set_var(self, name, var):
-        pass
+        return metadata[method]
 
-    def set_var_slice(self, name, start, count, var):
-        pass
+    def update(self, dt):
+        """
+        Advance the module with timestep dt
+        """
 
-    def set_var_index(self, name, index, var):
-        pass
+        method = "update"
 
-    def set_structure_field(self, name, id, field, value):
-        pass
+        A = None
+        metadata = {method : dt}
 
-    def set_logger(self, logger):
-        pass
+        send_array(self.socket, A, metadata)
+        A, metadata = recv_array(self.socket)
 
-    def __enter__(self):
+    # TODO:  Do we really need these two?
+    def inq_compound(self, name):
+        """
+        Return the number of fields of a compound type.
+        """
         pass
 
-    def __exit__(self, type, value, tb):
-        pass
+    def inq_compound_field(self, name, index):
+        """
+        Lookup the type,rank and shape of a compound field
+        """
+        pass

mmi/runner.py

@@ -184,6 +184,11 @@ def process_incoming(model, sockets, data):
                 #     arr[S] = data
                 # elif action['operator'] == 'add':
                 #     arr[S] += data
+            elif "initialize" in metadata:
+                config_file = metadata["initialize"]
+                model.initialize(config_file)
+            elif "finalize" in metadata:
+                model.finalize()
             else:
                 logger.warn("got unknown message {} from socket {}".format(str(metadata), sock))
             if sock.socket_type == zmq.REP:

mmi/tracker_client.py

@@ -28,3 +28,10 @@ def key_occurrence(self, key, update=True):
             if key in v:
                 result[str(v[key])] = k
         return result
+
+    def zmq_address(self, key):
+        """
+        Return a ZeroMQ address to the module with the provided key.
+        """
+        zmq_address = "tcp://" + self.database[key]['node'] + ":" + str(self.database[key]['ports']['REQ'])
+        return zmq_address