control channel progress

IPython/zmq/parallel/client.py

@@ -1,562 +1,602 b''
 #!/usr/bin/env python
 """A semi-synchronous Client for the ZMQ controller"""
 
 import time
 import threading
 
+from pprint import pprint
+
 from functools import wraps
 
 from IPython.external.decorator import decorator
 
 import streamsession as ss
 import zmq
 
 from remotenamespace import RemoteNamespace
 from view import DirectView
 
 def _push(ns):
     globals().update(ns)
 
 def _pull(keys):
     g = globals()
     if isinstance(keys, (list,tuple)):
         return map(g.get, keys)
     else:
         return g.get(keys)
 
 def _clear():
     globals().clear()
 
 def execute(code):
     exec code in globals()
 
 # decorators for methods:
 @decorator
 def spinfirst(f,self,*args,**kwargs):
     self.spin()
     return f(self, *args, **kwargs)
 
 @decorator
 def defaultblock(f, self, *args, **kwargs):
     block = kwargs.get('block',None)
     block = self.block if block is None else block
     saveblock = self.block
     self.block = block
     ret = f(self, *args, **kwargs)
     self.block = saveblock
     return ret
 
-
+class AbortedTask(object):
+    def __init__(self, msg_id):
+        self.msg_id = msg_id
 # @decorator
 # def checktargets(f):
 #     @wraps(f)
 #     def checked_method(self, *args, **kwargs):
 #         self._build_targets(kwargs['targets'])
 #         return f(self, *args, **kwargs)
 #     return checked_method
 
 
 # class _ZMQEventLoopThread(threading.Thread):
 #     
 #     def __init__(self, loop):
 #         self.loop = loop
 #         threading.Thread.__init__(self)
 #     
 #     def run(self):
 #         self.loop.start()
 # 
 class Client(object):
     """A semi-synchronous client to the IPython ZMQ controller
     
     Attributes
     ----------
     ids : set
         a set of engine IDs
         requesting the ids attribute always synchronizes
         the registration state. To request ids without synchronization,
         use _ids
     
     history : list of msg_ids
         a list of msg_ids, keeping track of all the execution
         messages you have submitted
     
     outstanding : set of msg_ids
         a set of msg_ids that have been submitted, but whose
         results have not been received
     
     results : dict
         a dict of all our results, keyed by msg_id
     
     block : bool
         determines default behavior when block not specified
         in execution methods
     
     Methods
     -------
     spin : flushes incoming results and registration state changes
             control methods spin, and requesting `ids` also ensures up to date
             
     barrier : wait on one or more msg_ids
     
     execution methods: apply/apply_bound/apply_to
         legacy: execute, run
     
-    control methods: queue_status, get_result
+    query methods: queue_status, get_result
+    
+    control methods: abort, kill
+    
+    
     
     """
     
     
     _connected=False
     _engines=None
     registration_socket=None
-    controller_socket=None
+    query_socket=None
+    control_socket=None
     notification_socket=None
     queue_socket=None
     task_socket=None
     block = False
     outstanding=None
     results = None
     history = None
+    debug = False
     
-    def __init__(self, addr, context=None, username=None):
+    def __init__(self, addr, context=None, username=None, debug=False):
         if context is None:
             context = zmq.Context()
         self.context = context
         self.addr = addr
         if username is None:
             self.session = ss.StreamSession()
         else:
             self.session = ss.StreamSession(username)
         self.registration_socket = self.context.socket(zmq.PAIR)
         self.registration_socket.setsockopt(zmq.IDENTITY, self.session.session)
         self.registration_socket.connect(addr)
         self._engines = {}
         self._ids = set()
         self.outstanding=set()
         self.results = {}
         self.history = []
+        self.debug = debug
+        self.session.debug = debug
         self._connect()
         
         self._notification_handlers = {'registration_notification' : self._register_engine,
                                     'unregistration_notification' : self._unregister_engine,
                                     }
         self._queue_handlers = {'execute_reply' : self._handle_execute_reply,
                                 'apply_reply' : self._handle_apply_reply}
         
     
     @property
     def ids(self):
         self._flush_notifications()
         return self._ids
     
     def _update_engines(self, engines):
         for k,v in engines.iteritems():
             eid = int(k)
-            self._engines[eid] = v
+            self._engines[eid] = bytes(v) # force not unicode
             self._ids.add(eid)
     
     def _build_targets(self, targets):
         if targets is None:
             targets = self._ids
         elif isinstance(targets, str):
             if targets.lower() == 'all':
                 targets = self._ids
             else:
                 raise TypeError("%r not valid str target, must be 'all'"%(targets))
         elif isinstance(targets, int):
             targets = [targets]
         return [self._engines[t] for t in targets], list(targets)
     
     def _connect(self):
         """setup all our socket connections to the controller"""
         if self._connected:
             return
         self._connected=True
         self.session.send(self.registration_socket, 'connection_request')
-        msg = self.session.recv(self.registration_socket,mode=0)[-1]
+        idents,msg = self.session.recv(self.registration_socket,mode=0)
+        if self.debug:
+            pprint(msg)
         msg = ss.Message(msg)
         content = msg.content
         if content.status == 'ok':
             if content.queue:
                 self.queue_socket = self.context.socket(zmq.PAIR)
                 self.queue_socket.setsockopt(zmq.IDENTITY, self.session.session)
                 self.queue_socket.connect(content.queue)
             if content.task:
                 self.task_socket = self.context.socket(zmq.PAIR)
                 self.task_socket.setsockopt(zmq.IDENTITY, self.session.session)
                 self.task_socket.connect(content.task)
             if content.notification:
                 self.notification_socket = self.context.socket(zmq.SUB)
                 self.notification_socket.connect(content.notification)
                 self.notification_socket.setsockopt(zmq.SUBSCRIBE, "")
-            if content.controller:
-                self.controller_socket = self.context.socket(zmq.PAIR)
-                self.controller_socket.setsockopt(zmq.IDENTITY, self.session.session)
-                self.controller_socket.connect(content.controller)
+            if content.query:
+                self.query_socket = self.context.socket(zmq.PAIR)
+                self.query_socket.setsockopt(zmq.IDENTITY, self.session.session)
+                self.query_socket.connect(content.query)
+            if content.control:
+                self.control_socket = self.context.socket(zmq.PAIR)
+                self.control_socket.setsockopt(zmq.IDENTITY, self.session.session)
+                self.control_socket.connect(content.control)
             self._update_engines(dict(content.engines))
                 
         else:
             self._connected = False
             raise Exception("Failed to connect!")
     
     #### handlers and callbacks for incoming messages #######
     def _register_engine(self, msg):
         content = msg['content']
         eid = content['id']
         d = {eid : content['queue']}
         self._update_engines(d)
         self._ids.add(int(eid))
 
     def _unregister_engine(self, msg):
         # print 'unregister',msg
         content = msg['content']
         eid = int(content['id'])
         if eid in self._ids:
             self._ids.remove(eid)
             self._engines.pop(eid)
         
     def _handle_execute_reply(self, msg):
         # msg_id = msg['msg_id']
         parent = msg['parent_header']
         msg_id = parent['msg_id']
         if msg_id not in self.outstanding:
             print "got unknown result: %s"%msg_id
         else:
             self.outstanding.remove(msg_id)
         self.results[msg_id] = ss.unwrap_exception(msg['content'])
     
     def _handle_apply_reply(self, msg):
-        # print msg
+        # pprint(msg)
         # msg_id = msg['msg_id']
         parent = msg['parent_header']
         msg_id = parent['msg_id']
         if msg_id not in self.outstanding:
             print "got unknown result: %s"%msg_id
         else:
             self.outstanding.remove(msg_id)
         content = msg['content']
         if content['status'] == 'ok':
             self.results[msg_id] = ss.unserialize_object(msg['buffers'])
+        elif content['status'] == 'aborted':
+            self.results[msg_id] = AbortedTask(msg_id)
+        elif content['status'] == 'resubmitted':
+            pass # handle resubmission
         else:
-            
             self.results[msg_id] = ss.unwrap_exception(content)
     
     def _flush_notifications(self):
         "flush incoming notifications of engine registrations"
         msg = self.session.recv(self.notification_socket, mode=zmq.NOBLOCK)
         while msg is not None:
+            if self.debug:
+                pprint(msg)
             msg = msg[-1]
             msg_type = msg['msg_type']
             handler = self._notification_handlers.get(msg_type, None)
             if handler is None:
                 raise Exception("Unhandled message type: %s"%msg.msg_type)
             else:
                 handler(msg)
             msg = self.session.recv(self.notification_socket, mode=zmq.NOBLOCK)
     
     def _flush_results(self, sock):
         "flush incoming task or queue results"
         msg = self.session.recv(sock, mode=zmq.NOBLOCK)
         while msg is not None:
+            if self.debug:
+                pprint(msg)
             msg = msg[-1]
             msg_type = msg['msg_type']
             handler = self._queue_handlers.get(msg_type, None)
             if handler is None:
                 raise Exception("Unhandled message type: %s"%msg.msg_type)
             else:
                 handler(msg)
             msg = self.session.recv(sock, mode=zmq.NOBLOCK)
     
+    def _flush_control(self, sock):
+        "flush incoming control replies"
+        msg = self.session.recv(sock, mode=zmq.NOBLOCK)
+        while msg is not None:
+            if self.debug:
+                pprint(msg)
+            msg = self.session.recv(sock, mode=zmq.NOBLOCK)
+    
     ###### get/setitem ########
     
     def __getitem__(self, key):
         if isinstance(key, int):
             if key not in self.ids:
                 raise IndexError("No such engine: %i"%key)
             return DirectView(self, key)
         
         if isinstance(key, slice):
             indices = range(len(self.ids))[key]
             ids = sorted(self._ids)
             key = [ ids[i] for i in indices ]
             # newkeys = sorted(self._ids)[thekeys[k]]
         
         if isinstance(key, (tuple, list, xrange)):
             _,targets = self._build_targets(list(key))
             return DirectView(self, targets)
         else:
             raise TypeError("key by int/iterable of ints only, not %s"%(type(key)))
     
     ############ begin real methods #############
     
     def spin(self):
         """flush incoming notifications and execution results."""
         if self.notification_socket:
             self._flush_notifications()
         if self.queue_socket:
             self._flush_results(self.queue_socket)
         if self.task_socket:
             self._flush_results(self.task_socket)
+        if self.control_socket:
+            self._flush_control(self.control_socket)
     
     @spinfirst
     def queue_status(self, targets=None, verbose=False):
         """fetch the status of engine queues
         
         Parameters
         ----------
         targets : int/str/list of ints/strs
                 the engines on which to execute
                 default : all
         verbose : bool
-                whether to return 
+                whether to return lengths only, or lists of ids for each element
                 
         """
         targets = self._build_targets(targets)[1]
         content = dict(targets=targets)
-        self.session.send(self.controller_socket, "queue_request", content=content)
-        idents,msg = self.session.recv(self.controller_socket, 0)
+        self.session.send(self.query_socket, "queue_request", content=content)
+        idents,msg = self.session.recv(self.query_socket, 0)
+        if self.debug:
+            pprint(msg)
         return msg['content']
         
     @spinfirst
-    def clear(self, targets=None):
+    @defaultblock
+    def clear(self, targets=None, block=None):
         """clear the namespace in target(s)"""
-        pass
+        targets = self._build_targets(targets)[0]
+        print targets
+        for t in targets:
+            self.session.send(self.control_socket, 'clear_request', content={},ident=t)
+        error = False
+        if self.block:
+            for i in range(len(targets)):
+                idents,msg = self.session.recv(self.control_socket,0)
+                if self.debug:
+                    pprint(msg)
+                if msg['content']['status'] != 'ok':
+                    error = msg['content']
+        if error:
+            return error
+        
     
     @spinfirst
-    def abort(self, targets=None):
+    @defaultblock
+    def abort(self, msg_ids = None, targets=None, block=None):
         """abort the Queues of target(s)"""
-        pass
+        targets = self._build_targets(targets)[0]
+        print targets
+        if isinstance(msg_ids, basestring):
+            msg_ids = [msg_ids]
+        content = dict(msg_ids=msg_ids)
+        for t in targets:
+            self.session.send(self.control_socket, 'abort_request', 
+                    content=content, ident=t)
+        error = False
+        if self.block:
+            for i in range(len(targets)):
+                idents,msg = self.session.recv(self.control_socket,0)
+                if self.debug:
+                    pprint(msg)
+                if msg['content']['status'] != 'ok':
+                    error = msg['content']
+        if error:
+            return error
     
+    @spinfirst
+    @defaultblock
+    def kill(self, targets=None, block=None):
+        """Terminates one or more engine processes."""
+        targets = self._build_targets(targets)[0]
+        print targets
+        for t in targets:
+            self.session.send(self.control_socket, 'kill_request', content={},ident=t)
+        error = False
+        if self.block:
+            for i in range(len(targets)):
+                idents,msg = self.session.recv(self.control_socket,0)
+                if self.debug:
+                    pprint(msg)
+                if msg['content']['status'] != 'ok':
+                    error = msg['content']
+        if error:
+            return error
+        
     @defaultblock
     def execute(self, code, targets='all', block=None):
         """executes `code` on `targets` in blocking or nonblocking manner.
         
         Parameters
         ----------
         code : str
                 the code string to be executed
         targets : int/str/list of ints/strs
                 the engines on which to execute
                 default : all
         block : bool
                 whether or not to wait until done
         """
         # block = self.block if block is None else block
         # saveblock = self.block
         # self.block = block
         result = self.apply(execute, (code,), targets=targets, block=block, bound=True)
         # self.block = saveblock
         return result
     
     def run(self, code, block=None):
         """runs `code` on an engine. 
         
         Calls to this are load-balanced.
         
         Parameters
         ----------
         code : str
                 the code string to be executed
         block : bool
                 whether or not to wait until done
         
         """
         result = self.apply(execute, (code,), targets=None, block=block, bound=False)
         return result
-        
-        # a = time.time()
-        # content = dict(code=code)
-        # b = time.time()
-        # msg = self.session.send(self.task_socket, 'execute_request', 
-        #         content=content)
-        # c = time.time()
-        # msg_id = msg['msg_id']
-        # self.outstanding.add(msg_id)
-        # self.history.append(msg_id)
-        # d = time.time()
-        # if block:
-        #     self.barrier(msg_id)
-        #     return self.results[msg_id]
-        # else:
-        #     return msg_id
     
     def _apply_balanced(self, f, args, kwargs, bound=True, block=None):
         """the underlying method for applying functions in a load balanced
         manner."""
         block = block if block is not None else self.block
         
         bufs = ss.pack_apply_message(f,args,kwargs)
         content = dict(bound=bound)
         msg = self.session.send(self.task_socket, "apply_request", 
                 content=content, buffers=bufs)
         msg_id = msg['msg_id']
         self.outstanding.add(msg_id)
         self.history.append(msg_id)
         if block:
             self.barrier(msg_id)
             return self.results[msg_id]
         else:
             return msg_id
     
     def _apply_direct(self, f, args, kwargs, bound=True, block=None, targets=None):
         """Then underlying method for applying functions to specific engines."""
         block = block if block is not None else self.block
         queues,targets = self._build_targets(targets)
-        
+        print queues
         bufs = ss.pack_apply_message(f,args,kwargs)
         content = dict(bound=bound)
         msg_ids = []
         for queue in queues:
             msg = self.session.send(self.queue_socket, "apply_request", 
                     content=content, buffers=bufs,ident=queue)
             msg_id = msg['msg_id']
             self.outstanding.add(msg_id)
             self.history.append(msg_id)
             msg_ids.append(msg_id)
         if block:
             self.barrier(msg_ids)
         else:
             if len(msg_ids) == 1:
                 return msg_ids[0]
             else:
                 return msg_ids
         if len(msg_ids) == 1:
             return self.results[msg_ids[0]]
         else:
             result = {}
             for target,mid in zip(targets, msg_ids):
                     result[target] = self.results[mid]
             return result
     
     def apply(self, f, args=None, kwargs=None, bound=True, block=None, targets=None):
         """calls f(*args, **kwargs) on a remote engine(s), returning the result.
         
         if self.block is False:
             returns msg_id or list of msg_ids
         else:
             returns actual result of f(*args, **kwargs)
         """
         args = args if args is not None else []
         kwargs = kwargs if kwargs is not None else {}
+        if not isinstance(args, (tuple, list)):
+            raise TypeError("args must be tuple or list, not %s"%type(args))
+        if not isinstance(kwargs, dict):
+            raise TypeError("kwargs must be dict, not %s"%type(kwargs))
         if targets is None:
             return self._apply_balanced(f,args,kwargs,bound=bound, block=block)
         else:
             return self._apply_direct(f, args, kwargs,
                         bound=bound,block=block, targets=targets)
     
-    # def apply_bound(self, f, *args, **kwargs):
-    #     """calls f(*args, **kwargs) on a remote engine. This does get
-    #     executed in an engine's namespace. The controller selects the 
-    #     target engine via 0MQ XREQ load balancing.
-    #     
-    #     if self.block is False:
-    #         returns msg_id
-    #     else:
-    #         returns actual result of f(*args, **kwargs)
-    #     """
-    #     return self._apply(f, args, kwargs, bound=True)
-    # 
-    # 
-    # def apply_to(self, targets, f, *args, **kwargs):
-    #     """calls f(*args, **kwargs) on a specific engine.
-    #     
-    #     if self.block is False:
-    #         returns msg_id
-    #     else:
-    #         returns actual result of f(*args, **kwargs)
-    #     
-    #     The target's namespace is not used here.
-    #     Use apply_bound_to() to access target's globals.
-    #     """
-    #     return self._apply_to(False, targets, f, args, kwargs)
-    # 
-    # def apply_bound_to(self, targets, f, *args, **kwargs):
-    #     """calls f(*args, **kwargs) on a specific engine.
-    #     
-    #     if self.block is False:
-    #         returns msg_id
-    #     else:
-    #         returns actual result of f(*args, **kwargs)
-    #     
-    #     This method has access to the target's globals
-    #     
-    #     """
-    #     return self._apply_to(f, args, kwargs)
-    # 
     def push(self, ns, targets=None, block=None):
         """push the contents of `ns` into the namespace on `target`"""
         if not isinstance(ns, dict):
             raise TypeError("Must be a dict, not %s"%type(ns))
         result = self.apply(_push, (ns,), targets=targets, block=block,bound=True)
         return result
     
     @spinfirst
     def pull(self, keys, targets=None, block=True):
         """pull objects from `target`'s namespace by `keys`"""
         
         result = self.apply(_pull, (keys,), targets=targets, block=block, bound=True)
         return result
     
     def barrier(self, msg_ids=None, timeout=-1):
         """waits on one or more `msg_ids`, for up to `timeout` seconds.
         
         Parameters
         ----------
         msg_ids : int, str, or list of ints and/or strs
                 ints are indices to self.history
                 strs are msg_ids
                 default: wait on all outstanding messages
         timeout : float
                 a time in seconds, after which to give up.
                 default is -1, which means no timeout
         
         Returns
         -------
         True : when all msg_ids are done
         False : timeout reached, msg_ids still outstanding
         """
         tic = time.time()
         if msg_ids is None:
             theids = self.outstanding
         else:
             if isinstance(msg_ids, (int, str)):
                 msg_ids = [msg_ids]
             theids = set()
             for msg_id in msg_ids:
                 if isinstance(msg_id, int):
                     msg_id = self.history[msg_id]
                 theids.add(msg_id)
         self.spin()
         while theids.intersection(self.outstanding):
             if timeout >= 0 and ( time.time()-tic ) > timeout:
                 break
             time.sleep(1e-3)
             self.spin()
         return len(theids.intersection(self.outstanding)) == 0
     
     @spinfirst
     def get_results(self, msg_ids,status_only=False):
         """returns the result of the execute or task request with `msg_id`"""
         if not isinstance(msg_ids, (list,tuple)):
             msg_ids = [msg_ids]
         theids = []
         for msg_id in msg_ids:
             if isinstance(msg_id, int):
                 msg_id = self.history[msg_id]
             theids.append(msg_id)
         
         content = dict(msg_ids=theids, status_only=status_only)
-        msg = self.session.send(self.controller_socket, "result_request", content=content)
-        zmq.select([self.controller_socket], [], [])
-        idents,msg = self.session.recv(self.controller_socket, zmq.NOBLOCK)
+        msg = self.session.send(self.query_socket, "result_request", content=content)
+        zmq.select([self.query_socket], [], [])
+        idents,msg = self.session.recv(self.query_socket, zmq.NOBLOCK)
+        if self.debug:
+            pprint(msg)
         
         # while True:
         #     try:
         #     except zmq.ZMQError:
         #         time.sleep(1e-3)
         #         continue
         #     else:
         #         break
         return msg['content']
     
     
  No newline at end of file

IPython/zmq/parallel/controller.py

@@ -1,770 +1,772 b''
 #!/usr/bin/env python
 # encoding: utf-8
 
 """The IPython Controller with 0MQ
 This is the master object that handles connections from engines, clients, and 
 """
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2009  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 from datetime import datetime
 
 import zmq
 from zmq.eventloop import zmqstream, ioloop
 import uuid
 
 # internal:
 from streamsession import Message, wrap_exception # default_unpacker as unpack, default_packer as pack
 from IPython.zmq.log import logger # a Logger object
 
 # from messages import json # use the same import switches
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 class ReverseDict(dict):
     """simple double-keyed subset of dict methods."""
     
     def __init__(self, *args, **kwargs):
         dict.__init__(self, *args, **kwargs)
         self.reverse = dict()
         for key, value in self.iteritems():
             self.reverse[value] = key
     
     def __getitem__(self, key):
         try:
             return dict.__getitem__(self, key)
         except KeyError:
             return self.reverse[key]
     
     def __setitem__(self, key, value):
         if key in self.reverse:
             raise KeyError("Can't have key %r on both sides!"%key)
         dict.__setitem__(self, key, value)
         self.reverse[value] = key
     
     def pop(self, key):
         value = dict.pop(self, key)
         self.d1.pop(value)
         return value
     
 
 class EngineConnector(object):
     """A simple object for accessing the various zmq connections of an object.
     Attributes are:
     id (int): engine ID
     uuid (str): uuid (unused?)
     queue (str): identity of queue's XREQ socket
     registration (str): identity of registration XREQ socket
     heartbeat (str): identity of heartbeat XREQ socket
     """
     id=0
     queue=None
     control=None
     registration=None
     heartbeat=None
     pending=None
     
     def __init__(self, id, queue, registration, control, heartbeat=None):
         logger.info("engine::Engine Connected: %i"%id)
         self.id = id
         self.queue = queue
         self.registration = registration
         self.control = control
         self.heartbeat = heartbeat
         
 class Controller(object):
     """The IPython Controller with 0MQ connections
     
     Parameters
     ==========
     loop: zmq IOLoop instance
     session: StreamSession object
     <removed> context: zmq context for creating new connections (?)
     registrar: ZMQStream for engine registration requests (XREP)
     clientele: ZMQStream for client connections (XREP)
                 not used for jobs, only query/control commands
     queue: ZMQStream for monitoring the command queue (SUB)
     heartbeat: HeartMonitor object checking the pulse of the engines
     db_stream: connection to db for out of memory logging of commands
                 NotImplemented
     queue_addr: zmq connection address of the XREP socket for the queue
     hb_addr: zmq connection address of the PUB socket for heartbeats
     task_addr: zmq connection address of the XREQ socket for task queue
     """
     # internal data structures:
     ids=None # engine IDs
     keytable=None
     engines=None
     clients=None
     hearts=None
     pending=None
     results=None
     tasks=None
     completed=None
     mia=None
     incoming_registrations=None
     registration_timeout=None
     
     #objects from constructor:
     loop=None
     registrar=None
     clientelle=None
     queue=None
     heartbeat=None
     notifier=None
     db=None
     client_addr=None
     engine_addrs=None
     
     
     def __init__(self, loop, session, queue, registrar, heartbeat, clientele, notifier, db, engine_addrs, client_addrs):
         """
         # universal:
         loop: IOLoop for creating future connections
         session: streamsession for sending serialized data
         # engine:
         queue: ZMQStream for monitoring queue messages
         registrar: ZMQStream for engine registration
         heartbeat: HeartMonitor object for tracking engines
         # client:
         clientele: ZMQStream for client connections
         # extra:
         db: ZMQStream for db connection (NotImplemented)
         engine_addrs: zmq address/protocol dict for engine connections
         client_addrs: zmq address/protocol dict for client connections
         """
         self.ids = set()
         self.keytable={}
         self.incoming_registrations={}
         self.engines = {}
         self.by_ident = {}
         self.clients = {}
         self.hearts = {}
         self.mia = set()
         
         # self.sockets = {}
         self.loop = loop
         self.session = session
         self.registrar = registrar
         self.clientele = clientele
         self.queue = queue
         self.heartbeat = heartbeat
         self.notifier = notifier
         self.db = db
         
         self.client_addrs = client_addrs
         assert isinstance(client_addrs['queue'], str)
         # self.hb_addrs = hb_addrs
         self.engine_addrs = engine_addrs
         assert isinstance(engine_addrs['queue'], str)
         assert len(engine_addrs['heartbeat']) == 2
         
         
         # register our callbacks
         self.registrar.on_recv(self.dispatch_register_request)
         self.clientele.on_recv(self.dispatch_client_msg)
         self.queue.on_recv(self.dispatch_queue_traffic)
         
         if heartbeat is not None:
             heartbeat.add_heart_failure_handler(self.handle_heart_failure)
             heartbeat.add_new_heart_handler(self.handle_new_heart)
         
         if self.db is not None:
             self.db.on_recv(self.dispatch_db)
             
         self.client_handlers = {'queue_request': self.queue_status,
                                 'result_request': self.get_results,
                                 'purge_request': self.purge_results,
                                 'resubmit_request': self.resubmit_task,
                                 }
         
         self.registrar_handlers = {'registration_request' : self.register_engine,
                                 'unregistration_request' : self.unregister_engine,
                                 'connection_request': self.connection_request,
         
         }
         # 
         # this is the stuff that will move to DB:
         self.results = {} # completed results
         self.pending = {} # pending messages, keyed by msg_id
         self.queues = {} # pending msg_ids keyed by engine_id
         self.tasks = {} # pending msg_ids submitted as tasks, keyed by client_id
         self.completed = {} # completed msg_ids keyed by engine_id
         self.registration_timeout = max(5000, 2*self.heartbeat.period)
         
         logger.info("controller::created controller")
     
     def _new_id(self):
         """gemerate a new ID"""
         newid = 0
         incoming = [id[0] for id in self.incoming_registrations.itervalues()]
         # print newid, self.ids, self.incoming_registrations
         while newid in self.ids or newid in incoming:
             newid += 1
         return newid
     
     
     #-----------------------------------------------------------------------------
     # message validation
     #-----------------------------------------------------------------------------
     def _validate_targets(self, targets):
         """turn any valid targets argument into a list of integer ids"""
         if targets is None:
             # default to all
             targets = self.ids
             
         if isinstance(targets, (int,str,unicode)):
             # only one target specified
             targets = [targets]
         _targets = []
         for t in targets:
             # map raw identities to ids
             if isinstance(t, (str,unicode)):
                 t = self.by_ident.get(t, t)
             _targets.append(t)
         targets = _targets
         bad_targets = [ t for t in targets if t not in self.ids ]
         if bad_targets:
             raise IndexError("No Such Engine: %r"%bad_targets)
         if not targets:
             raise IndexError("No Engines Registered")
         return targets
     
     def _validate_client_msg(self, msg):
         """validates and unpacks headers of a message. Returns False if invalid,
         (ident, header, parent, content)"""
         client_id = msg[0]
         try:
             msg = self.session.unpack_message(msg[1:], content=True)
         except:
             logger.error("client::Invalid Message %s"%msg)
             return False
         
         msg_type = msg.get('msg_type', None)
         if msg_type is None:
             return False
         header = msg.get('header')
         # session doesn't handle split content for now:
         return client_id, msg
         
     
     #-----------------------------------------------------------------------------
     # dispatch methods (1 per socket)
     #-----------------------------------------------------------------------------
     
     def dispatch_register_request(self, msg):
         """"""
         logger.debug("registration::dispatch_register_request(%s)"%msg)
         idents,msg = self.session.feed_identities(msg)
         print idents,msg, len(msg)
         try:
             msg = self.session.unpack_message(msg,content=True)
         except Exception, e:
             logger.error("registration::got bad registration message: %s"%msg)
             raise e
             return
         
         msg_type = msg['msg_type']
         content = msg['content']
         
         handler = self.registrar_handlers.get(msg_type, None)
         if handler is None:
             logger.error("registration::got bad registration message: %s"%msg)
         else:
             handler(idents, msg)
     
     def dispatch_queue_traffic(self, msg):
         """all ME and Task queue messages come through here"""
         logger.debug("queue traffic: %s"%msg[:2])
         switch = msg[0]
         idents, msg = self.session.feed_identities(msg[1:])
         if switch == 'in':
             self.save_queue_request(idents, msg)
         elif switch == 'out':
             self.save_queue_result(idents, msg)
         elif switch == 'intask':
             self.save_task_request(idents, msg)
         elif switch == 'outtask':
             self.save_task_result(idents, msg)
         elif switch == 'tracktask':
             self.save_task_destination(idents, msg)
+        elif switch in ('incontrol', 'outcontrol'):
+            pass
         else:
             logger.error("Invalid message topic: %s"%switch)
         
     
     def dispatch_client_msg(self, msg):
         """Route messages from clients"""
         idents, msg = self.session.feed_identities(msg)
         client_id = idents[0]
         try:
             msg = self.session.unpack_message(msg, content=True)
         except:
             content = wrap_exception()
             logger.error("Bad Client Message: %s"%msg)
             self.session.send(self.clientele, "controller_error", ident=client_id, 
                     content=content)
             return
         
         # print client_id, header, parent, content
         #switch on message type:
         msg_type = msg['msg_type']
         logger.info("client:: client %s requested %s"%(client_id, msg_type))
         handler = self.client_handlers.get(msg_type, None)
         try:
             assert handler is not None, "Bad Message Type: %s"%msg_type
         except:
             content = wrap_exception()
             logger.error("Bad Message Type: %s"%msg_type)
             self.session.send(self.clientele, "controller_error", ident=client_id, 
                     content=content)
             return
         else:
             handler(client_id, msg)
             
     def dispatch_db(self, msg):
         """"""
         raise NotImplementedError
     
     #---------------------------------------------------------------------------
     # handler methods (1 per event)
     #---------------------------------------------------------------------------
     
     #----------------------- Heartbeat --------------------------------------
     
     def handle_new_heart(self, heart):
         """handler to attach to heartbeater.
         Called when a new heart starts to beat.
         Triggers completion of registration."""
         logger.debug("heartbeat::handle_new_heart(%r)"%heart)
         if heart not in self.incoming_registrations:
             logger.info("heartbeat::ignoring new heart: %r"%heart)
         else:
             self.finish_registration(heart)
         
     
     def handle_heart_failure(self, heart):
         """handler to attach to heartbeater.
         called when a previously registered heart fails to respond to beat request.
         triggers unregistration"""
         logger.debug("heartbeat::handle_heart_failure(%r)"%heart)
         eid = self.hearts.get(heart, None)
         if eid is None:
             logger.info("heartbeat::ignoring heart failure %r"%heart)
         else:
             self.unregister_engine(heart, dict(content=dict(id=eid)))
     
     #----------------------- MUX Queue Traffic ------------------------------
     
     def save_queue_request(self, idents, msg):
         queue_id, client_id = idents[:2]
             
         try:
             msg = self.session.unpack_message(msg, content=False)
         except:
             logger.error("queue::client %r sent invalid message to %r: %s"%(client_id, queue_id, msg))
             return
         
         eid = self.by_ident.get(queue_id, None)
         if eid is None:
             logger.error("queue::target %r not registered"%queue_id)
             logger.debug("queue::    valid are: %s"%(self.by_ident.keys()))
             return
             
         header = msg['header']
         msg_id = header['msg_id']
         info = dict(submit=datetime.now(),
                     received=None,
                     engine=(eid, queue_id))
         self.pending[msg_id] = ( msg, info )
         self.queues[eid][0].append(msg_id)
     
     def save_queue_result(self, idents, msg):
         client_id, queue_id = idents[:2]
         
         try:
             msg = self.session.unpack_message(msg, content=False)
         except:
             logger.error("queue::engine %r sent invalid message to %r: %s"%(
                     queue_id,client_id, msg))
             return
         
         eid = self.by_ident.get(queue_id, None)
         if eid is None:
             logger.error("queue::unknown engine %r is sending a reply: "%queue_id)
             logger.debug("queue::       %s"%msg[2:])
             return
         
         parent = msg['parent_header']
         if not parent:
             return
         msg_id = parent['msg_id']
         self.results[msg_id] = msg
         if msg_id in self.pending:
             self.pending.pop(msg_id)
             self.queues[eid][0].remove(msg_id)
             self.completed[eid].append(msg_id)
         else:
             logger.debug("queue:: unknown msg finished %s"%msg_id)
             
     #--------------------- Task Queue Traffic ------------------------------
     
     def save_task_request(self, idents, msg):
         client_id = idents[0]
         
         try:
             msg = self.session.unpack_message(msg, content=False)
         except:
             logger.error("task::client %r sent invalid task message: %s"%(
                     client_id, msg))
             return
         
         header = msg['header']
         msg_id = header['msg_id']
         self.mia.add(msg_id)
         self.pending[msg_id] = msg
         if not self.tasks.has_key(client_id):
             self.tasks[client_id] = []
         self.tasks[client_id].append(msg_id)
     
     def save_task_result(self, idents, msg):
         client_id = idents[0]
         try:
             msg = self.session.unpack_message(msg, content=False)
         except:
             logger.error("task::invalid task result message send to %r: %s"%(
                     client_id, msg))
             return
         
         parent = msg['parent_header']
         if not parent:
             # print msg
             # logger.warn("")
             return
         msg_id = parent['msg_id']
         self.results[msg_id] = msg
         if msg_id in self.pending:
             self.pending.pop(msg_id)
             if msg_id in self.mia:
                 self.mia.remove(msg_id)
         else:
             logger.debug("task:: unknown task %s finished"%msg_id)
     
     def save_task_destination(self, idents, msg):
         try:
             msg = self.session.unpack_message(msg, content=True)
         except:
             logger.error("task::invalid task tracking message")
             return
         content = msg['content']
         print content
         msg_id = content['msg_id']
         engine_uuid = content['engine_id']
         for eid,queue_id in self.keytable.iteritems():
             if queue_id == engine_uuid:
                 break
         
         logger.info("task:: task %s arrived on %s"%(msg_id, eid))
         if msg_id in self.mia:
             self.mia.remove(msg_id)
         else:
             logger.debug("task::task %s not listed as MIA?!"%(msg_id))
         self.tasks[engine_uuid].append(msg_id)
     
     def mia_task_request(self, idents, msg):
         client_id = idents[0]
         content = dict(mia=self.mia,status='ok')
         self.session.send('mia_reply', content=content, idents=client_id)
         
         
             
     #-------------------- Registration -----------------------------
         
     def connection_request(self, client_id, msg):
         """reply with connection addresses for clients"""
         logger.info("client::client %s connected"%client_id)
         content = dict(status='ok')
         content.update(self.client_addrs)
         jsonable = {}
         for k,v in self.keytable.iteritems():
             jsonable[str(k)] = v
         content['engines'] = jsonable
         self.session.send(self.registrar, 'connection_reply', content, parent=msg, ident=client_id)
     
     def register_engine(self, reg, msg):
         """register an engine"""
         content = msg['content']
         try:
             queue = content['queue']
         except KeyError:
             logger.error("registration::queue not specified")
             return
         heart = content.get('heartbeat', None)
         """register a new engine, and create the socket(s) necessary"""
         eid = self._new_id()
         # print (eid, queue, reg, heart)
         
         logger.debug("registration::register_engine(%i, %r, %r, %r)"%(eid, queue, reg, heart))
         
         content = dict(id=eid,status='ok')
         content.update(self.engine_addrs)
         # check if requesting available IDs:
         if queue in self.by_ident:
             content = {'status': 'error', 'reason': "queue_id %r in use"%queue}
         elif heart in self.hearts: # need to check unique hearts?
             content = {'status': 'error', 'reason': "heart_id %r in use"%heart}
         else:
             for h, pack in self.incoming_registrations.iteritems():
                 if heart == h:
                     content = {'status': 'error', 'reason': "heart_id %r in use"%heart}
                     break
                 elif queue == pack[1]:
                     content = {'status': 'error', 'reason': "queue_id %r in use"%queue}
                     break
         
         msg = self.session.send(self.registrar, "registration_reply", 
                 content=content, 
                 ident=reg)
         
         if content['status'] == 'ok':
             if heart in self.heartbeat.hearts:
                 # already beating
                 self.incoming_registrations[heart] = (eid,queue,reg,None)
                 self.finish_registration(heart)
             else:
                 purge = lambda : self._purge_stalled_registration(heart)
                 dc = ioloop.DelayedCallback(purge, self.registration_timeout, self.loop)
                 dc.start()
                 self.incoming_registrations[heart] = (eid,queue,reg,dc)
         else:
             logger.error("registration::registration %i failed: %s"%(eid, content['reason']))
         return eid
     
     def unregister_engine(self, ident, msg):
         try:
             eid = msg['content']['id']
         except:
             logger.error("registration::bad engine id for unregistration: %s"%ident)
             return
         logger.info("registration::unregister_engine(%s)"%eid)
         content=dict(id=eid, queue=self.engines[eid].queue)
         self.ids.remove(eid)
         self.keytable.pop(eid)
         ec = self.engines.pop(eid)
         self.hearts.pop(ec.heartbeat)
         self.by_ident.pop(ec.queue)
         self.completed.pop(eid)
         for msg_id in self.queues.pop(eid)[0]:
             msg = self.pending.pop(msg_id)
             ############## TODO: HANDLE IT ################
         
         if self.notifier:
             self.session.send(self.notifier, "unregistration_notification", content=content)
     
     def finish_registration(self, heart):
         try: 
             (eid,queue,reg,purge) = self.incoming_registrations.pop(heart)
         except KeyError:
             logger.error("registration::tried to finish nonexistant registration")
             return
         logger.info("registration::finished registering engine %i:%r"%(eid,queue))
         if purge is not None:
             purge.stop()
         control = queue
         self.ids.add(eid)
         self.keytable[eid] = queue
         self.engines[eid] = EngineConnector(eid, queue, reg, control, heart)
         self.by_ident[queue] = eid
         self.queues[eid] = ([],[])
         self.completed[eid] = list()
         self.hearts[heart] = eid
         content = dict(id=eid, queue=self.engines[eid].queue)
         if self.notifier:
             self.session.send(self.notifier, "registration_notification", content=content)
     
     def _purge_stalled_registration(self, heart):
         if heart in self.incoming_registrations:
             eid = self.incoming_registrations.pop(heart)[0]
             logger.info("registration::purging stalled registration: %i"%eid)
         else:
             pass
             
     #------------------- Client Requests -------------------------------
     
     def check_load(self, client_id, msg):
         content = msg['content']
         try:
             targets = content['targets']
             targets = self._validate_targets(targets)
         except:
             content = wrap_exception()
             self.session.send(self.clientele, "controller_error", 
                     content=content, ident=client_id)
             return
         
         content = dict(status='ok')
         # loads = {}
         for t in targets:
             content[str(t)] = len(self.queues[t])
         self.session.send(self.clientele, "load_reply", content=content, ident=client_id)
             
     
     def queue_status(self, client_id, msg):
         """handle queue_status request"""
         content = msg['content']
         targets = content['targets']
         try:
             targets = self._validate_targets(targets)
         except:
             content = wrap_exception()
             self.session.send(self.clientele, "controller_error", 
                     content=content, ident=client_id)
             return
         verbose = msg.get('verbose', False)
         content = dict()
         for t in targets:
             queue = self.queues[t]
             completed = self.completed[t]
             if not verbose:
                 queue = len(queue)
                 completed = len(completed)
             content[str(t)] = {'queue': queue, 'completed': completed }
             # pending
         self.session.send(self.clientele, "queue_reply", content=content, ident=client_id)
     
     def job_status(self, client_id, msg):
         """handle queue_status request"""
         content = msg['content']
         msg_ids = content['msg_ids']
         try:
             targets = self._validate_targets(targets)
         except:
             content = wrap_exception()
             self.session.send(self.clientele, "controller_error", 
                     content=content, ident=client_id)
             return
         verbose = msg.get('verbose', False)
         content = dict()
         for t in targets:
             queue = self.queues[t]
             completed = self.completed[t]
             if not verbose:
                 queue = len(queue)
                 completed = len(completed)
             content[str(t)] = {'queue': queue, 'completed': completed }
             # pending
         self.session.send(self.clientele, "queue_reply", content=content, ident=client_id)
     
     def purge_results(self, client_id, msg):
         content = msg['content']
         msg_ids = content.get('msg_ids', [])
         reply = dict(status='ok')
         if msg_ids == 'all':
             self.results = {}
         else:
             for msg_id in msg_ids:
                 if msg_id in self.results:
                     self.results.pop(msg_id)
                 else:
                     if msg_id in self.pending:
                         reply = dict(status='error', reason="msg pending: %r"%msg_id)
                     else:
                         reply = dict(status='error', reason="No such msg: %r"%msg_id)
                     break
             eids = content.get('engine_ids', [])
             for eid in eids:
                 if eid not in self.engines:
                     reply = dict(status='error', reason="No such engine: %i"%eid)
                     break
                 msg_ids = self.completed.pop(eid)
                 for msg_id in msg_ids:
                     self.results.pop(msg_id)
         
         self.sesison.send(self.clientele, 'purge_reply', content=reply, ident=client_id)
     
     def resubmit_task(self, client_id, msg, buffers):
         content = msg['content']
         header = msg['header']
         
         
         msg_ids = content.get('msg_ids', [])
         reply = dict(status='ok')
         if msg_ids == 'all':
             self.results = {}
         else:
             for msg_id in msg_ids:
                 if msg_id in self.results:
                     self.results.pop(msg_id)
                 else:
                     if msg_id in self.pending:
                         reply = dict(status='error', reason="msg pending: %r"%msg_id)
                     else:
                         reply = dict(status='error', reason="No such msg: %r"%msg_id)
                     break
             eids = content.get('engine_ids', [])
             for eid in eids:
                 if eid not in self.engines:
                     reply = dict(status='error', reason="No such engine: %i"%eid)
                     break
                 msg_ids = self.completed.pop(eid)
                 for msg_id in msg_ids:
                     self.results.pop(msg_id)
         
         self.sesison.send(self.clientele, 'purge_reply', content=reply, ident=client_id)
     
     def get_results(self, client_id, msg):
         """get the result of 1 or more messages"""
         content = msg['content']
         msg_ids = set(content['msg_ids'])
         statusonly = content.get('status_only', False)
         pending = []
         completed = []
         content = dict(status='ok')
         content['pending'] = pending
         content['completed'] = completed
         for msg_id in msg_ids:
             if msg_id in self.pending:
                 pending.append(msg_id)
             elif msg_id in self.results:
                 completed.append(msg_id)
                 if not statusonly:
                     content[msg_id] = self.results[msg_id]['content']
             else:
                 content = dict(status='error')
                 content['reason'] = 'no such message: '+msg_id
                 break
         self.session.send(self.clientele, "result_reply", content=content, 
                                             parent=msg, ident=client_id)
     
 
 
 ############ OLD METHODS for Python Relay Controller ###################
     def _validate_engine_msg(self, msg):
         """validates and unpacks headers of a message. Returns False if invalid,
         (ident, message)"""
         ident = msg[0]
         try:
             msg = self.session.unpack_message(msg[1:], content=False)
         except:
             logger.error("engine.%s::Invalid Message %s"%(ident, msg))
             return False
         
         try:
             eid = msg.header.username
             assert self.engines.has_key(eid)
         except:
             logger.error("engine::Invalid Engine ID %s"%(ident))
             return False
         
         return eid, msg
     
 
         
  No newline at end of file

IPython/zmq/parallel/engine.py

@@ -1,143 +1,141 b''
 #!/usr/bin/env python
 """A simple engine that talks to a controller over 0MQ.
 it handles registration, etc. and launches a kernel
 connected to the Controller's queue(s).
 """
 import sys
 import time
 import traceback
 import uuid
+from pprint import pprint
 
 import zmq
 from zmq.eventloop import ioloop, zmqstream
 
 from streamsession import Message, StreamSession
 from client import Client
 import streamkernel as kernel
 import heartmonitor
 # import taskthread
 # from log import logger
 
 
 def printer(*msg):
-    print msg
+    pprint(msg)
 
 class Engine(object):
     """IPython engine"""
     
     id=None
     context=None
     loop=None
     session=None
-    queue_id=None
-    control_id=None
-    heart_id=None
+    ident=None
     registrar=None
     heart=None
     kernel=None
     
-    def __init__(self, context, loop, session, registrar, client, queue_id=None, heart_id=None):
+    def __init__(self, context, loop, session, registrar, client, ident=None, heart_id=None):
         self.context = context
         self.loop = loop
         self.session = session
         self.registrar = registrar
         self.client = client
-        self.queue_id = queue_id or str(uuid.uuid4())
-        self.heart_id = heart_id or self.queue_id
+        self.ident = ident if ident else str(uuid.uuid4())
         self.registrar.on_send(printer)
         
     def register(self):
         
-        content = dict(queue=self.queue_id, heartbeat=self.heart_id)
+        content = dict(queue=self.ident, heartbeat=self.ident, control=self.ident)
         self.registrar.on_recv(self.complete_registration)
         self.session.send(self.registrar, "registration_request",content=content)
     
     def complete_registration(self, msg):
         # print msg
         idents,msg = self.session.feed_identities(msg)
         msg = Message(self.session.unpack_message(msg))
         if msg.content.status == 'ok':
             self.session.username = str(msg.content.id)
             queue_addr = msg.content.queue
             if queue_addr:
                 queue = self.context.socket(zmq.PAIR)
-                queue.setsockopt(zmq.IDENTITY, self.queue_id)
+                queue.setsockopt(zmq.IDENTITY, self.ident)
                 queue.connect(str(queue_addr))
                 self.queue = zmqstream.ZMQStream(queue, self.loop)
             
             control_addr = msg.content.control
             if control_addr:
                 control = self.context.socket(zmq.PAIR)
-                control.setsockopt(zmq.IDENTITY, self.queue_id)
+                control.setsockopt(zmq.IDENTITY, self.ident)
                 control.connect(str(control_addr))
                 self.control = zmqstream.ZMQStream(control, self.loop)
             
             task_addr = msg.content.task
             print task_addr
             if task_addr:
                 # task as stream:
                 task = self.context.socket(zmq.PAIR)
                 task.connect(str(task_addr))
                 self.task_stream = zmqstream.ZMQStream(task, self.loop)
                 # TaskThread:
                 # mon_addr = msg.content.monitor
-                # task = taskthread.TaskThread(zmq.PAIR, zmq.PUB, self.queue_id)
+                # task = taskthread.TaskThread(zmq.PAIR, zmq.PUB, self.ident)
                 # task.connect_in(str(task_addr))
                 # task.connect_out(str(mon_addr))
                 # self.task_stream = taskthread.QueueStream(*task.queues)
                 # task.start()
             
             hbs = msg.content.heartbeat
-            self.heart = heartmonitor.Heart(*map(str, hbs), heart_id=self.heart_id)
+            self.heart = heartmonitor.Heart(*map(str, hbs), heart_id=self.ident)
             self.heart.start()
             # ioloop.DelayedCallback(self.heart.start, 1000, self.loop).start()
             # placeholder for now:
             pub = self.context.socket(zmq.PUB)
             pub = zmqstream.ZMQStream(pub, self.loop)
             # create and start the kernel
             self.kernel = kernel.Kernel(self.session, self.control, self.queue, pub, self.task_stream, self.client)
             self.kernel.start()
         else:
             # logger.error("Registration Failed: %s"%msg)
             raise Exception("Registration Failed: %s"%msg)
         
         # logger.info("engine::completed registration with id %s"%self.session.username)
         
         print msg
     
     def unregister(self):
         self.session.send(self.registrar, "unregistration_request", content=dict(id=int(self.session.username)))
         time.sleep(1)
         sys.exit(0)
     
     def start(self):
         print "registering"
         self.register()
         
 
 if __name__ == '__main__':
     
     loop = ioloop.IOLoop.instance()
     session = StreamSession()
     ctx = zmq.Context()
 
     ip = '127.0.0.1'
     reg_port = 10101
     connection = ('tcp://%s' % ip) + ':%i'
     reg_conn = connection % reg_port
     print reg_conn
     print >>sys.__stdout__, "Starting the engine..."
     
     reg = ctx.socket(zmq.PAIR)
     reg.connect(reg_conn)
     reg = zmqstream.ZMQStream(reg, loop)
     client = Client(reg_conn)
     if len(sys.argv) > 1:
         queue_id=sys.argv[1]
     else:
         queue_id = None
     
     e = Engine(ctx, loop, session, reg, client, queue_id)
     dc = ioloop.DelayedCallback(e.start, 500, loop)
     dc.start()
     loop.start()
  No newline at end of file

IPython/zmq/parallel/streamkernel.py

@@ -1,482 +1,510 b''
 #!/usr/bin/env python
 """
 Kernel adapted from kernel.py to use ZMQ Streams
 """
 
 import __builtin__
+import os
 import sys
 import time
 import traceback
 from signal import SIGTERM, SIGKILL
+from pprint import pprint
 
 from code import CommandCompiler
 
 import zmq
 from zmq.eventloop import ioloop, zmqstream
 
 from streamsession import StreamSession, Message, extract_header, serialize_object,\
                 unpack_apply_message
 from IPython.zmq.completer import KernelCompleter
 
+def printer(*args):
+    pprint(args)
+
 class OutStream(object):
     """A file like object that publishes the stream to a 0MQ PUB socket."""
 
     def __init__(self, session, pub_socket, name, max_buffer=200):
         self.session = session
         self.pub_socket = pub_socket
         self.name = name
         self._buffer = []
         self._buffer_len = 0
         self.max_buffer = max_buffer
         self.parent_header = {}
 
     def set_parent(self, parent):
         self.parent_header = extract_header(parent)
 
     def close(self):
         self.pub_socket = None
 
     def flush(self):
         if self.pub_socket is None:
             raise ValueError(u'I/O operation on closed file')
         else:
             if self._buffer:
                 data = ''.join(self._buffer)
                 content = {u'name':self.name, u'data':data}
                 # msg = self.session.msg(u'stream', content=content,
                 #                        parent=self.parent_header)
                 msg = self.session.send(self.pub_socket, u'stream', content=content, parent=self.parent_header)
                 # print>>sys.__stdout__, Message(msg)
                 # self.pub_socket.send_json(msg)
                 self._buffer_len = 0
                 self._buffer = []
 
     def isattr(self):
         return False
 
     def next(self):
         raise IOError('Read not supported on a write only stream.')
 
     def read(self, size=None):
         raise IOError('Read not supported on a write only stream.')
 
     readline=read
 
     def write(self, s):
         if self.pub_socket is None:
             raise ValueError('I/O operation on closed file')
         else:
             self._buffer.append(s)
             self._buffer_len += len(s)
             self._maybe_send()
 
     def _maybe_send(self):
         if '\n' in self._buffer[-1]:
             self.flush()
         if self._buffer_len > self.max_buffer:
             self.flush()
 
     def writelines(self, sequence):
         if self.pub_socket is None:
             raise ValueError('I/O operation on closed file')
         else:
             for s in sequence:
                 self.write(s)
 
 
 class DisplayHook(object):
 
     def __init__(self, session, pub_socket):
         self.session = session
         self.pub_socket = pub_socket
         self.parent_header = {}
 
     def __call__(self, obj):
         if obj is None:
             return
 
         __builtin__._ = obj
         # msg = self.session.msg(u'pyout', {u'data':repr(obj)},
         #                        parent=self.parent_header)
         # self.pub_socket.send_json(msg)
         self.session.send(self.pub_socket, u'pyout', content={u'data':repr(obj)}, parent=self.parent_header)
 
     def set_parent(self, parent):
         self.parent_header = extract_header(parent)
 
 
 class RawInput(object):
 
     def __init__(self, session, socket):
         self.session = session
         self.socket = socket
 
     def __call__(self, prompt=None):
         msg = self.session.msg(u'raw_input')
         self.socket.send_json(msg)
         while True:
             try:
                 reply = self.socket.recv_json(zmq.NOBLOCK)
             except zmq.ZMQError, e:
                 if e.errno == zmq.EAGAIN:
                     pass
                 else:
                     raise
             else:
                 break
         return reply[u'content'][u'data']
 
 
 class Kernel(object):
 
     def __init__(self, session, control_stream, reply_stream, pub_stream, 
                                             task_stream=None, client=None):
         self.session = session
         self.control_stream = control_stream
+        self.control_socket = control_stream.socket
         self.reply_stream = reply_stream
         self.task_stream = task_stream
         self.pub_stream = pub_stream
         self.client = client
         self.user_ns = {}
         self.history = []
         self.compiler = CommandCompiler()
         self.completer = KernelCompleter(self.user_ns)
         self.aborted = set()
         
         # Build dict of handlers for message types
         self.queue_handlers = {}
         self.control_handlers = {}
         for msg_type in ['execute_request', 'complete_request', 'apply_request']:
             self.queue_handlers[msg_type] = getattr(self, msg_type)
         
         for msg_type in ['kill_request', 'abort_request']:
             self.control_handlers[msg_type] = getattr(self, msg_type)
 
     #-------------------- control handlers -----------------------------
+    def abort_queues(self):
+        for stream in (self.task_stream, self.reply_stream):
+            if stream:
+                self.abort_queue(stream)
     
     def abort_queue(self, stream):
         while True:
             try:
                 msg = self.session.recv(stream, zmq.NOBLOCK,content=True)
             except zmq.ZMQError, e:
                 if e.errno == zmq.EAGAIN:
                     break
                 else:
                     return
             else:
                 if msg is None:
                     return
                 else:
                     idents,msg = msg
                 
                 # assert self.reply_socketly_socket.rcvmore(), "Unexpected missing message part."
                 # msg = self.reply_socket.recv_json()
             print>>sys.__stdout__, "Aborting:"
             print>>sys.__stdout__, Message(msg)
             msg_type = msg['msg_type']
             reply_type = msg_type.split('_')[0] + '_reply'
             # reply_msg = self.session.msg(reply_type, {'status' : 'aborted'}, msg)
             # self.reply_socket.send(ident,zmq.SNDMORE)
             # self.reply_socket.send_json(reply_msg)
             reply_msg = self.session.send(stream, reply_type, 
                         content={'status' : 'aborted'}, parent=msg, ident=idents)
             print>>sys.__stdout__, Message(reply_msg)
             # We need to wait a bit for requests to come in. This can probably
             # be set shorter for true asynchronous clients.
             time.sleep(0.05)
     
     def abort_request(self, stream, ident, parent):
+        """abort a specifig msg by id"""
         msg_ids = parent['content'].get('msg_ids', None)
+        if isinstance(msg_ids, basestring):
+            msg_ids = [msg_ids]
         if not msg_ids:
-            self.abort_queue(self.task_stream)
-            self.abort_queue(self.reply_stream)
+            self.abort_queues()
         for mid in msg_ids:
-            self.aborted.add(mid)
+            self.aborted.add(str(mid))
         
         content = dict(status='ok')
-        self.session.send(stream, 'abort_reply', content=content, parent=parent,
+        reply_msg = self.session.send(stream, 'abort_reply', content=content, parent=parent,
                                                                     ident=ident)
+        print>>sys.__stdout__, Message(reply_msg)
     
     def kill_request(self, stream, idents, parent):
-        self.abort_queue(self.reply_stream)
-        if self.task_stream:
-            self.abort_queue(self.task_stream)
+        """kill ourselves.  This should really be handled in an external process"""
+        self.abort_queues()
         msg = self.session.send(stream, 'kill_reply', ident=idents, parent=parent, 
                 content = dict(status='ok'))
         # we can know that a message is done if we *don't* use streams, but 
         # use a socket directly with MessageTracker
-        time.sleep(1)
+        time.sleep(.5)
         os.kill(os.getpid(), SIGTERM)
-        time.sleep(.25)
+        time.sleep(1)
         os.kill(os.getpid(), SIGKILL)
     
     def dispatch_control(self, msg):
         idents,msg = self.session.feed_identities(msg, copy=False)
         msg = self.session.unpack_message(msg, content=True, copy=False)
         
         header = msg['header']
         msg_id = header['msg_id']
         
         handler = self.control_handlers.get(msg['msg_type'], None)
         if handler is None:
             print >> sys.__stderr__, "UNKNOWN CONTROL MESSAGE TYPE:", msg
         else:
-            handler(stream, idents, msg)
+            handler(self.control_stream, idents, msg)
     
     def flush_control(self):
         while any(zmq.select([self.control_socket],[],[],1e-4)):
             try:
                 msg = self.control_socket.recv_multipart(zmq.NOBLOCK, copy=False)
             except zmq.ZMQError, e:
                 if e.errno != zmq.EAGAIN:
                     raise e
                 return
             else:
                 self.dispatch_control(msg)
     
 
     #-------------------- queue helpers ------------------------------
     
     def check_dependencies(self, dependencies):
         if not dependencies:
             return True
         if len(dependencies) == 2 and dependencies[0] in 'any all'.split():
             anyorall = dependencies[0]
             dependencies = dependencies[1]
         else:
             anyorall = 'all'
         results = self.client.get_results(dependencies,status_only=True)
         if results['status'] != 'ok':
             return False
         
         if anyorall == 'any':
             if not results['completed']:
                 return False
         else:
             if results['pending']:
                 return False
         
         return True
     
+    def check_aborted(self, msg_id):
+        return msg_id in self.aborted
+    
+    def unmet_dependencies(self, stream, idents, msg):
+        reply_type = msg['msg_type'].split('_')[0] + '_reply'
+        content = dict(status='resubmitted', reason='unmet dependencies')
+        reply_msg = self.session.send(stream, reply_type, 
+                    content=content, parent=msg, ident=idents)
+        ### TODO: actually resubmit it ###
+    
     #-------------------- queue handlers -----------------------------
     
     def execute_request(self, stream, ident, parent):
         try:
             code = parent[u'content'][u'code']
         except:
             print>>sys.__stderr__, "Got bad msg: "
             print>>sys.__stderr__, Message(parent)
             return
         # pyin_msg = self.session.msg(u'pyin',{u'code':code}, parent=parent)
         # self.pub_stream.send(pyin_msg)
         self.session.send(self.pub_stream, u'pyin', {u'code':code},parent=parent)
         try:
             comp_code = self.compiler(code, '<zmq-kernel>')
             # allow for not overriding displayhook
             if hasattr(sys.displayhook, 'set_parent'):
                 sys.displayhook.set_parent(parent)
             exec comp_code in self.user_ns, self.user_ns
         except:
             # result = u'error'
             etype, evalue, tb = sys.exc_info()
             tb = traceback.format_exception(etype, evalue, tb)
             exc_content = {
                 u'status' : u'error',
                 u'traceback' : tb,
                 u'etype' : unicode(etype),
                 u'evalue' : unicode(evalue)
             }
             # exc_msg = self.session.msg(u'pyerr', exc_content, parent)
             self.session.send(self.pub_stream, u'pyerr', exc_content, parent=parent)
             reply_content = exc_content
         else:
             reply_content = {'status' : 'ok'}
         # reply_msg = self.session.msg(u'execute_reply', reply_content, parent)
         # self.reply_socket.send(ident, zmq.SNDMORE)
         # self.reply_socket.send_json(reply_msg)
         reply_msg = self.session.send(stream, u'execute_reply', reply_content, parent=parent, ident=ident)
         # print>>sys.__stdout__, Message(reply_msg)
         if reply_msg['content']['status'] == u'error':
-            self.abort_queue()
+            self.abort_queues()
 
     def complete_request(self, stream, ident, parent):
         matches = {'matches' : self.complete(parent),
                    'status' : 'ok'}
         completion_msg = self.session.send(stream, 'complete_reply',
                                            matches, parent, ident)
         # print >> sys.__stdout__, completion_msg
 
     def complete(self, msg):
         return self.completer.complete(msg.content.line, msg.content.text)
     
     def apply_request(self, stream, ident, parent):
         try:
             content = parent[u'content']
             bufs = parent[u'buffers']
             msg_id = parent['header']['msg_id']
             bound = content.get('bound', False)
         except:
             print>>sys.__stderr__, "Got bad msg: "
             print>>sys.__stderr__, Message(parent)
             return
         # pyin_msg = self.session.msg(u'pyin',{u'code':code}, parent=parent)
         # self.pub_stream.send(pyin_msg)
         # self.session.send(self.pub_stream, u'pyin', {u'code':code},parent=parent)
         try:
             # allow for not overriding displayhook
             if hasattr(sys.displayhook, 'set_parent'):
                 sys.displayhook.set_parent(parent)
             # exec "f(*args,**kwargs)" in self.user_ns, self.user_ns
             if bound:
                 working = self.user_ns
                 suffix = str(msg_id).replace("-","")
                 prefix = "_"
                 
             else:
                 working = dict()
-                suffix = prefix = ""
+                suffix = prefix = "_" # prevent keyword collisions with lambda
             f,args,kwargs = unpack_apply_message(bufs, working, copy=False)
             # if f.fun
             fname = prefix+f.func_name.strip('<>')+suffix
             argname = prefix+"args"+suffix
             kwargname = prefix+"kwargs"+suffix
             resultname = prefix+"result"+suffix
             
             ns = { fname : f, argname : args, kwargname : kwargs }
             # print ns
             working.update(ns)
             code = "%s=%s(*%s,**%s)"%(resultname, fname, argname, kwargname)
             exec code in working, working
             result = working.get(resultname)
             # clear the namespace
             if bound:
                 for key in ns.iterkeys():
                     self.user_ns.pop(key)
             else:
                 del working
             
             packed_result,buf = serialize_object(result)
             result_buf = [packed_result]+buf
         except:
             result = u'error'
             etype, evalue, tb = sys.exc_info()
             tb = traceback.format_exception(etype, evalue, tb)
             exc_content = {
                 u'status' : u'error',
                 u'traceback' : tb,
                 u'etype' : unicode(etype),
                 u'evalue' : unicode(evalue)
             }
             # exc_msg = self.session.msg(u'pyerr', exc_content, parent)
             self.session.send(self.pub_stream, u'pyerr', exc_content, parent=parent)
             reply_content = exc_content
             result_buf = []
         else:
             reply_content = {'status' : 'ok'}
         # reply_msg = self.session.msg(u'execute_reply', reply_content, parent)
         # self.reply_socket.send(ident, zmq.SNDMORE)
         # self.reply_socket.send_json(reply_msg)
         reply_msg = self.session.send(stream, u'apply_reply', reply_content, parent=parent, ident=ident,buffers=result_buf)
         # print>>sys.__stdout__, Message(reply_msg)
         if reply_msg['content']['status'] == u'error':
-            self.abort_queue()
+            self.abort_queues()
     
     def dispatch_queue(self, stream, msg):
         self.flush_control()
         idents,msg = self.session.feed_identities(msg, copy=False)
         msg = self.session.unpack_message(msg, content=True, copy=False)
         
         header = msg['header']
         msg_id = header['msg_id']
         dependencies = header.get('dependencies', [])
-        
         if self.check_aborted(msg_id):
-            return self.abort_reply(stream, msg)
+            self.aborted.remove(msg_id)
+            # is it safe to assume a msg_id will not be resubmitted?
+            reply_type = msg['msg_type'].split('_')[0] + '_reply'
+            reply_msg = self.session.send(stream, reply_type, 
+                        content={'status' : 'aborted'}, parent=msg, ident=idents)
+            return
         if not self.check_dependencies(dependencies):
-            return self.unmet_dependencies(stream, msg)
-        
+            return self.unmet_dependencies(stream, idents, msg)
         handler = self.queue_handlers.get(msg['msg_type'], None)
         if handler is None:
             print >> sys.__stderr__, "UNKNOWN MESSAGE TYPE:", msg
         else:
             handler(stream, idents, msg)
     
     def start(self):
         #### stream mode:
         if self.control_stream:
             self.control_stream.on_recv(self.dispatch_control, copy=False)
+            self.control_stream.on_err(printer)
         if self.reply_stream:
             self.reply_stream.on_recv(lambda msg: 
                     self.dispatch_queue(self.reply_stream, msg), copy=False)
+            self.reply_stream.on_err(printer)
         if self.task_stream:
             self.task_stream.on_recv(lambda msg: 
                     self.dispatch_queue(self.task_stream, msg), copy=False)
+            self.task_stream.on_err(printer)
         
         #### while True mode:
         # while True:
         #     idle = True
         #     try:
         #         msg = self.reply_stream.socket.recv_multipart(
         #                     zmq.NOBLOCK, copy=False)
         #     except zmq.ZMQError, e:
         #         if e.errno != zmq.EAGAIN:
         #             raise e
         #     else:
         #         idle=False
         #         self.dispatch_queue(self.reply_stream, msg)
         #             
         #     if not self.task_stream.empty():
         #         idle=False
         #         msg = self.task_stream.recv_multipart()
         #         self.dispatch_queue(self.task_stream, msg)
         #     if idle:
         #         # don't busywait
         #         time.sleep(1e-3)
 
 
 def main():
     raise Exception("Don't run me anymore")
     loop = ioloop.IOLoop.instance()
     c = zmq.Context()
 
     ip = '127.0.0.1'
     port_base = 5575
     connection = ('tcp://%s' % ip) + ':%i'
     rep_conn = connection % port_base
     pub_conn = connection % (port_base+1)
 
     print >>sys.__stdout__, "Starting the kernel..."
     # print >>sys.__stdout__, "XREQ Channel:", rep_conn
     # print >>sys.__stdout__, "PUB Channel:", pub_conn
 
     session = StreamSession(username=u'kernel')
 
     reply_socket = c.socket(zmq.XREQ)
     reply_socket.connect(rep_conn)
 
     pub_socket = c.socket(zmq.PUB)
     pub_socket.connect(pub_conn)
 
     stdout = OutStream(session, pub_socket, u'stdout')
     stderr = OutStream(session, pub_socket, u'stderr')
     sys.stdout = stdout
     sys.stderr = stderr
 
     display_hook = DisplayHook(session, pub_socket)
     sys.displayhook = display_hook
     reply_stream = zmqstream.ZMQStream(reply_socket,loop)
     pub_stream = zmqstream.ZMQStream(pub_socket,loop)
     kernel = Kernel(session, reply_stream, pub_stream)
 
     # For debugging convenience, put sleep and a string in the namespace, so we
     # have them every time we start.
     kernel.user_ns['sleep'] = time.sleep
     kernel.user_ns['s'] = 'Test string'
     
     print >>sys.__stdout__, "Use Ctrl-\\ (NOT Ctrl-C!) to terminate."
     kernel.start()
     loop.start()
 
 
 if __name__ == '__main__':
     main()

IPython/zmq/parallel/streamsession.py

@@ -1,443 +1,447 b''
 #!/usr/bin/env python
 """edited session.py to work with streams, and move msg_type to the header
 """
 
 
 import os
 import sys
 import traceback
 import pprint
 import uuid
 
 import zmq
 from zmq.utils import jsonapi
 from zmq.eventloop.zmqstream import ZMQStream
 
 from IPython.zmq.pickleutil import can, uncan, canSequence, uncanSequence
 from IPython.zmq.newserialized import serialize, unserialize
 
 try:
     import cPickle
     pickle = cPickle
 except:
     cPickle = None
     import pickle
 
 # packer priority: jsonlib[2], cPickle, simplejson/json, pickle
 json_name = '' if not jsonapi.jsonmod else jsonapi.jsonmod.__name__
 if json_name in ('jsonlib', 'jsonlib2'):
     use_json = True
 elif json_name:
     if cPickle is None:
         use_json = True
     else:
         use_json = False
 else:
     use_json = False
 
 if use_json:
     default_packer = jsonapi.dumps
     default_unpacker = jsonapi.loads
 else:
     default_packer = lambda o: pickle.dumps(o,-1)
     default_unpacker = pickle.loads
 
 
 DELIM="<IDS|MSG>"
 
 def wrap_exception():
     etype, evalue, tb = sys.exc_info()
     tb = traceback.format_exception(etype, evalue, tb)
     exc_content = {
         u'status' : u'error',
         u'traceback' : tb,
         u'etype' : unicode(etype),
         u'evalue' : unicode(evalue)
     }
     return exc_content
 
 class KernelError(Exception):
     pass
 
 def unwrap_exception(content):
     err = KernelError(content['etype'], content['evalue'])
     err.evalue = content['evalue']
     err.etype = content['etype']
     err.traceback = ''.join(content['traceback'])
     return err
     
 
 class Message(object):
     """A simple message object that maps dict keys to attributes.
 
     A Message can be created from a dict and a dict from a Message instance
     simply by calling dict(msg_obj)."""
     
     def __init__(self, msg_dict):
         dct = self.__dict__
         for k, v in dict(msg_dict).iteritems():
             if isinstance(v, dict):
                 v = Message(v)
             dct[k] = v
 
     # Having this iterator lets dict(msg_obj) work out of the box.
     def __iter__(self):
         return iter(self.__dict__.iteritems())
     
     def __repr__(self):
         return repr(self.__dict__)
 
     def __str__(self):
         return pprint.pformat(self.__dict__)
 
     def __contains__(self, k):
         return k in self.__dict__
 
     def __getitem__(self, k):
         return self.__dict__[k]
 
 
 def msg_header(msg_id, msg_type, username, session):
     return locals()
     # return {
     #     'msg_id' : msg_id,
     #     'msg_type': msg_type,
     #     'username' : username,
     #     'session' : session
     # }
 
 
 def extract_header(msg_or_header):
     """Given a message or header, return the header."""
     if not msg_or_header:
         return {}
     try:
         # See if msg_or_header is the entire message.
         h = msg_or_header['header']
     except KeyError:
         try:
             # See if msg_or_header is just the header
             h = msg_or_header['msg_id']
         except KeyError:
             raise
         else:
             h = msg_or_header
     if not isinstance(h, dict):
         h = dict(h)
     return h
 
 def rekey(dikt):
     """rekey a dict that has been forced to use str keys where there should be
     ints by json.  This belongs in the jsonutil added by fperez."""
     for k in dikt.iterkeys():
         if isinstance(k, str):
             ik=fk=None
             try:
                 ik = int(k)
             except ValueError:
                 try:
                     fk = float(k)
                 except ValueError:
                     continue
             if ik is not None:
                 nk = ik
             else:
                 nk = fk
             if nk in dikt:
                 raise KeyError("already have key %r"%nk)
             dikt[nk] = dikt.pop(k)
     return dikt
 
 def serialize_object(obj, threshold=64e-6):
     """serialize an object into a list of sendable buffers.
     
     Returns: (pmd, bufs)
         where pmd is the pickled metadata wrapper, and bufs
         is a list of data buffers"""
     # threshold is 100 B
     databuffers = []
     if isinstance(obj, (list, tuple)):
         clist = canSequence(obj)
         slist = map(serialize, clist)
         for s in slist:
             if s.getDataSize() > threshold:
                 databuffers.append(s.getData())
                 s.data = None
         return pickle.dumps(slist,-1), databuffers
     elif isinstance(obj, dict):
         sobj = {}
         for k in sorted(obj.iterkeys()):
             s = serialize(can(obj[k]))
             if s.getDataSize() > threshold:
                 databuffers.append(s.getData())
                 s.data = None
             sobj[k] = s
         return pickle.dumps(sobj,-1),databuffers
     else:
         s = serialize(can(obj))
         if s.getDataSize() > threshold:
             databuffers.append(s.getData())
             s.data = None
         return pickle.dumps(s,-1),databuffers
             
         
 def unserialize_object(bufs):
     """reconstruct an object serialized by serialize_object from data buffers"""
     bufs = list(bufs)
     sobj = pickle.loads(bufs.pop(0))
     if isinstance(sobj, (list, tuple)):
         for s in sobj:
             if s.data is None:
                 s.data = bufs.pop(0)
         return uncanSequence(map(unserialize, sobj))
     elif isinstance(sobj, dict):
         newobj = {}
         for k in sorted(sobj.iterkeys()):
             s = sobj[k]
             if s.data is None:
                 s.data = bufs.pop(0)
             newobj[k] = uncan(unserialize(s))
         return newobj
     else:
         if sobj.data is None:
             sobj.data = bufs.pop(0)
         return uncan(unserialize(sobj))
 
 def pack_apply_message(f, args, kwargs, threshold=64e-6):
     """pack up a function, args, and kwargs to be sent over the wire
     as a series of buffers. Any object whose data is larger than `threshold`
     will not have their data copied (currently only numpy arrays support zero-copy)"""
     msg = [pickle.dumps(can(f),-1)]
     databuffers = [] # for large objects
     sargs, bufs = serialize_object(args,threshold)
     msg.append(sargs)
     databuffers.extend(bufs)
     skwargs, bufs = serialize_object(kwargs,threshold)
     msg.append(skwargs)
     databuffers.extend(bufs)
     msg.extend(databuffers)
     return msg
 
 def unpack_apply_message(bufs, g=None, copy=True):
     """unpack f,args,kwargs from buffers packed by pack_apply_message()
     Returns: original f,args,kwargs"""
     bufs = list(bufs) # allow us to pop
     assert len(bufs) >= 3, "not enough buffers!"
     if not copy:
         for i in range(3):
             bufs[i] = bufs[i].bytes
     cf = pickle.loads(bufs.pop(0))
     sargs = list(pickle.loads(bufs.pop(0)))
     skwargs = dict(pickle.loads(bufs.pop(0)))
     # print sargs, skwargs
     f = cf.getFunction(g)
     for sa in sargs:
         if sa.data is None:
             m = bufs.pop(0)
             if sa.getTypeDescriptor() in ('buffer', 'ndarray'):
                 if copy:
                     sa.data = buffer(m)
                 else:
                     sa.data = m.buffer
             else:
                 if copy:
                     sa.data = m
                 else:
                     sa.data = m.bytes
     
     args = uncanSequence(map(unserialize, sargs), g)
     kwargs = {}
     for k in sorted(skwargs.iterkeys()):
         sa = skwargs[k]
         if sa.data is None:
             sa.data = bufs.pop(0)
         kwargs[k] = uncan(unserialize(sa), g)
     
     return f,args,kwargs
 
 class StreamSession(object):
     """tweaked version of IPython.zmq.session.Session, for development in Parallel"""
-
+    debug=False
     def __init__(self, username=None, session=None, packer=None, unpacker=None):
         if username is None:
             username = os.environ.get('USER','username')
         self.username = username
         if session is None:
             self.session = str(uuid.uuid4())
         else:
             self.session = session
         self.msg_id = str(uuid.uuid4())
         if packer is None:
             self.pack = default_packer
         else:
             if not callable(packer):
                 raise TypeError("packer must be callable, not %s"%type(packer))
             self.pack = packer
         
         if unpacker is None:
             self.unpack = default_unpacker
         else:
             if not callable(unpacker):
                 raise TypeError("unpacker must be callable, not %s"%type(unpacker))
             self.unpack = unpacker
         
         self.none = self.pack({})
             
     def msg_header(self, msg_type):
         h = msg_header(self.msg_id, msg_type, self.username, self.session)
         self.msg_id = str(uuid.uuid4())
         return h
 
     def msg(self, msg_type, content=None, parent=None, subheader=None):
         msg = {}
         msg['header'] = self.msg_header(msg_type)
         msg['msg_id'] = msg['header']['msg_id']
         msg['parent_header'] = {} if parent is None else extract_header(parent)
         msg['msg_type'] = msg_type
         msg['content'] = {} if content is None else content
         sub = {} if subheader is None else subheader
         msg['header'].update(sub)
         return msg
 
     def send(self, stream, msg_type, content=None, buffers=None, parent=None, subheader=None, ident=None):
         """send a message via stream"""
         msg = self.msg(msg_type, content, parent, subheader)
         buffers = [] if buffers is None else buffers
         to_send = []
         if isinstance(ident, list):
             # accept list of idents
             to_send.extend(ident)
         elif ident is not None:
             to_send.append(ident)
         to_send.append(DELIM)
         to_send.append(self.pack(msg['header']))
         to_send.append(self.pack(msg['parent_header']))
         # if parent is None:
         #     to_send.append(self.none)
         # else:
         #     to_send.append(self.pack(dict(parent)))
         if content is None:
             content = self.none
         elif isinstance(content, dict):
             content = self.pack(content)
         elif isinstance(content, str):
             # content is already packed, as in a relayed message
             pass
         else:
             raise TypeError("Content incorrect type: %s"%type(content))
         to_send.append(content)
         flag = 0
         if buffers:
             flag = zmq.SNDMORE
         stream.send_multipart(to_send, flag, copy=False)
         for b in buffers[:-1]:
             stream.send(b, flag, copy=False)
         if buffers:
             stream.send(buffers[-1], copy=False)
         omsg = Message(msg)
+        if self.debug:
+            pprint.pprint(omsg)
+            pprint.pprint(to_send)
+            pprint.pprint(buffers)
         return omsg
 
     def recv(self, socket, mode=zmq.NOBLOCK, content=True, copy=True):
         """receives and unpacks a message
         returns [idents], msg"""
         if isinstance(socket, ZMQStream):
             socket = socket.socket
         try:
             msg = socket.recv_multipart(mode)
         except zmq.ZMQError, e:
             if e.errno == zmq.EAGAIN:
                 # We can convert EAGAIN to None as we know in this case
                 # recv_json won't return None.
                 return None
             else:
                 raise
         # return an actual Message object
         # determine the number of idents by trying to unpack them.
         # this is terrible:
         idents, msg = self.feed_identities(msg, copy)
         try:
             return idents, self.unpack_message(msg, content=content, copy=copy)
         except Exception, e:
             print idents, msg
             # TODO: handle it
             raise e
     
     def feed_identities(self, msg, copy=True):
         """This is a completely horrible thing, but it strips the zmq
         ident prefixes off of a message. It will break if any identities
         are unpackable by self.unpack."""
         msg = list(msg)
         idents = []
         while len(msg) > 3:
             if copy:
                 s = msg[0]
             else:
                 s = msg[0].bytes
             if s == DELIM:
                 msg.pop(0)
                 break
             else:
                 idents.append(s)
                 msg.pop(0)
                 
         return idents, msg
     
     def unpack_message(self, msg, content=True, copy=True):
         """return a message object from the format
         sent by self.send.
         
         parameters:
         
         content : bool (True)
             whether to unpack the content dict (True), 
             or leave it serialized (False)
         
         copy : bool (True)
             whether to return the bytes (True), 
             or the non-copying Message object in each place (False)
         
         """
         if not len(msg) >= 3:
             raise TypeError("malformed message, must have at least 3 elements")
         message = {}
         if not copy:
             for i in range(3):
                 msg[i] = msg[i].bytes
         message['header'] = self.unpack(msg[0])
         message['msg_type'] = message['header']['msg_type']
         message['parent_header'] = self.unpack(msg[1])
         if content:
             message['content'] = self.unpack(msg[2])
         else:
             message['content'] = msg[2]
     
         # message['buffers'] = msg[3:]
         # else:
         #     message['header'] = self.unpack(msg[0].bytes)
         #     message['msg_type'] = message['header']['msg_type']
         #     message['parent_header'] = self.unpack(msg[1].bytes)
         #     if content:
         #         message['content'] = self.unpack(msg[2].bytes)
         #     else:
         #         message['content'] = msg[2].bytes
         
         message['buffers'] = msg[3:]# [ m.buffer for m in msg[3:] ]
         return message
             
         
 
 def test_msg2obj():
     am = dict(x=1)
     ao = Message(am)
     assert ao.x == am['x']
 
     am['y'] = dict(z=1)
     ao = Message(am)
     assert ao.y.z == am['y']['z']
     
     k1, k2 = 'y', 'z'
     assert ao[k1][k2] == am[k1][k2]
     
     am2 = dict(ao)
     assert am['x'] == am2['x']
     assert am['y']['z'] == am2['y']['z']

IPython/zmq/parallel/view.py

@@ -1,141 +1,157 b''
 #!/usr/bin/env python
 """Views"""
 
 from IPython.external.decorator import decorator
 
 
 @decorator
 def myblock(f, self, *args, **kwargs):
     block = self.client.block
     self.client.block = self.block
     ret = f(self, *args, **kwargs)
     self.client.block = block
     return ret
 
 class View(object):
     """Base View class"""
     _targets = None
     block=None
     
     def __init__(self, client, targets):
         self.client = client
         self._targets = targets
         self.block = client.block
     
     def __repr__(self):
         strtargets = str(self._targets)
         if len(strtargets) > 16:
             strtargets = strtargets[:12]+'...]'
         return "<%s %s>"%(self.__class__.__name__, strtargets)
     
     @property
     def results(self):
         return self.client.results
     
     @property
     def targets(self):
         return self._targets
     
     @targets.setter
     def targets(self, value):
         raise TypeError("Cannot set my targets argument after construction!")
     
     def apply(self, f, *args, **kwargs):
         """calls f(*args, **kwargs) on remote engines, returning the result.
         
         This method does not involve the engine's namespace.
         
         if self.block is False:
             returns msg_id
         else:
             returns actual result of f(*args, **kwargs)
         """
         return self.client.apply(f, args, kwargs, block=self.block, targets=self.targets, bound=False)
     
     def apply_async(self, f, *args, **kwargs):
         """calls f(*args, **kwargs) on remote engines in a nonblocking manner.
         
         This method does not involve the engine's namespace.
         
         returns msg_id
         """
         return self.client.apply(f,args,kwargs, block=False, targets=self.targets, bound=False)
     
     def apply_sync(self, f, *args, **kwargs):
         """calls f(*args, **kwargs) on remote engines in a blocking manner,
          returning the result.
         
         This method does not involve the engine's namespace.
         
         returns: actual result of f(*args, **kwargs)
         """
         return self.client.apply(f,args,kwargs, block=True, targets=self.targets, bound=False)
     
     def apply_bound(self, f, *args, **kwargs):
         """calls f(*args, **kwargs) bound to engine namespace(s).
         
         if self.block is False:
             returns msg_id
         else:
             returns actual result of f(*args, **kwargs)
         
         This method has access to the targets' globals
         
         """
         return self.client.apply(f, args, kwargs, block=self.block, targets=self.targets, bound=True)
     
     def apply_async_bound(self, f, *args, **kwargs):
         """calls f(*args, **kwargs) bound to engine namespace(s) 
         in a nonblocking manner.
         
         returns: msg_id
         
         This method has access to the targets' globals
         
         """
         return self.client.apply(f, args, kwargs, block=False, targets=self.targets, bound=True)
     
     def apply_sync_bound(self, f, *args, **kwargs):
         """calls f(*args, **kwargs) bound to engine namespace(s), waiting for the result.
         
         returns: actual result of f(*args, **kwargs)
         
         This method has access to the targets' globals
         
         """
-        return self.client.apply(f, args, kwargs, block=False, targets=self.targets, bound=True)
+        return self.client.apply(f, args, kwargs, block=True, targets=self.targets, bound=True)
     
 
 class DirectView(View):
     """Direct Multiplexer View"""
     
     def update(self, ns):
         """update remote namespace with dict `ns`"""
         return self.client.push(ns, targets=self.targets, block=self.block)
     
     def get(self, key_s):
         """get object(s) by `key_s` from remote namespace
         will return one object if it is a key.
         It also takes a list of keys, and will return a list of objects."""
         # block = block if block is not None else self.block
         return self.client.pull(key_s, block=self.block, targets=self.targets)
     
     push = update
     pull = get
     
     def __getitem__(self, key):
         return self.get(key)
     
     def __setitem__(self,key,value):
         self.update({key:value})
     
-    def clear(self):
-        """clear the remote namespace"""
-        return self.client.clear(targets=self.targets,block=self.block)
+    def clear(self, block=False):
+        """Clear the remote namespaces on my engines."""
+        block = block if block is not None else self.block
+        return self.client.clear(targets=self.targets,block=block)
+    
+    def kill(self, block=True):
+        """Kill my engines."""
+        block = block if block is not None else self.block
+        return self.client.kill(targets=self.targets,block=block)
     
-    def abort(self):
-        return self.client.abort(targets=self.targets,block=self.block)
+    def abort(self, msg_ids=None, block=None):
+        """Abort jobs on my engines.
+        
+        Parameters
+        ----------
+        
+        msg_ids : None, str, list of strs, optional
+            if None: abort all jobs.
+            else: abort specific msg_id(s).
+        """
+        block = block if block is not None else self.block
+        return self.client.abort(msg_ids=msg_ids, targets=self.targets, block=block)
 
 class LoadBalancedView(View):
     _targets=None
     
  No newline at end of file

examples/zmqontroller/controller.py

@@ -1,139 +1,139 b''
 #!/usr/bin/env python
 """A script to launch a controller with all its queues and connect it to a logger"""
 
 import time
 import logging
 
 import zmq
 from zmq.devices import ProcessMonitoredQueue, ThreadMonitoredQueue
 from zmq.eventloop import ioloop
 from zmq.eventloop.zmqstream import ZMQStream
 from zmq.log import handlers
 
 from IPython.zmq import log
 from IPython.zmq.parallel import controller, heartmonitor, streamsession as session
 
   
   
 
 def setup():
     """setup a basic controller and open client,registrar, and logging ports. Start the Queue and the heartbeat"""
     ctx = zmq.Context(1)
     loop = ioloop.IOLoop.instance()
     
     # port config
     # config={}
     execfile('config.py', globals())
     iface = config['interface']
     logport = config['logport']
     rport = config['regport']
     cport = config['clientport']
     cqport = config['cqueueport']
     eqport = config['equeueport']
     ctport = config['ctaskport']
     etport = config['etaskport']
     ccport = config['ccontrolport']
     ecport = config['econtrolport']
     hport = config['heartport']
     nport = config['notifierport']
     
     # setup logging
     lsock = ctx.socket(zmq.PUB)
     lsock.connect('%s:%i'%(iface,logport))
     # connected=False
     # while not connected:
     #     try:
     #     except:
     #         logport = logport + 1
     #     else:
     #         connected=True
     #         
     handler = handlers.PUBHandler(lsock)
     handler.setLevel(logging.DEBUG)
     handler.root_topic = "controller"
     log.logger.addHandler(handler)
     time.sleep(.5)
     
     ### Engine connections ###
     
     # Engine registrar socket
     reg = ZMQStream(ctx.socket(zmq.XREP), loop)
     reg.bind("%s:%i"%(iface, rport))
     
     # heartbeat
     hpub = ctx.socket(zmq.PUB)
     hpub.bind("%s:%i"%(iface, hport))
     hrep = ctx.socket(zmq.XREP)
     hrep.bind("%s:%i"%(iface, hport+1))
     
     hb = heartmonitor.HeartMonitor(loop, ZMQStream(hpub,loop), ZMQStream(hrep,loop),2500)
     hb.start()
     
     ### Client connections ###
     # Clientele socket
     c = ZMQStream(ctx.socket(zmq.XREP), loop)
     c.bind("%s:%i"%(iface, cport))
     
     n = ZMQStream(ctx.socket(zmq.PUB), loop)
     n.bind("%s:%i"%(iface, nport))
     
     thesession = session.StreamSession(username="controller")
     
     
     
     # build and launch the queue
     sub = ctx.socket(zmq.SUB)
     sub.setsockopt(zmq.SUBSCRIBE, "")
     monport = sub.bind_to_random_port(iface)
     sub = ZMQStream(sub, loop)
     
     # Multiplexer Queue (in a Process)
     q = ProcessMonitoredQueue(zmq.XREP, zmq.XREP, zmq.PUB, 'in', 'out')
     q.bind_in("%s:%i"%(iface, cqport))
     q.bind_out("%s:%i"%(iface, eqport))
     q.connect_mon("%s:%i"%(iface, monport))
     q.daemon=True
     q.start()
     
     # Control Queue (in a Process)
     q = ProcessMonitoredQueue(zmq.XREP, zmq.XREP, zmq.PUB, 'incontrol', 'outcontrol')
     q.bind_in("%s:%i"%(iface, ccport))
     q.bind_out("%s:%i"%(iface, ecport))
     q.connect_mon("%s:%i"%(iface, monport))
     q.daemon=True
     q.start()
     
     # Task Queue (in a Process)
     q = ProcessMonitoredQueue(zmq.XREP, zmq.XREQ, zmq.PUB, 'intask', 'outtask')
     q.bind_in("%s:%i"%(iface, ctport))
     q.bind_out("%s:%i"%(iface, etport))
     q.connect_mon("%s:%i"%(iface, monport))
     q.daemon=True
     q.start()
     
     time.sleep(.25)
     
     # build connection dicts
     engine_addrs = {
         'control' : "%s:%i"%(iface, ecport),
         'queue': "%s:%i"%(iface, eqport),
         'heartbeat': ("%s:%i"%(iface, hport), "%s:%i"%(iface, hport+1)),
         'task' : "%s:%i"%(iface, etport),
         'monitor' : "%s:%i"%(iface, monport),
         }
     
     client_addrs = {
         'control' : "%s:%i"%(iface, ccport),
-        'controller': "%s:%i"%(iface, cport),
+        'query': "%s:%i"%(iface, cport),
         'queue': "%s:%i"%(iface, cqport),
         'task' : "%s:%i"%(iface, ctport),
         'notification': "%s:%i"%(iface, nport)
         }
     con = controller.Controller(loop, thesession, sub, reg, hb, c, n, None, engine_addrs, client_addrs)
     
     return loop
     
 
 if __name__ == '__main__':
     loop = setup()
     loop.start()
  No newline at end of file