def dsp_outlet(self, outlet): try: return (self.outlet_objects[outlet].dsp_obj, 0) except IndexError: log.error("Programming error: asked for outlet '%d' in patch %s but it has %d" % (outlet, self.name, len(self.outlet_objects))) return (None, 0)
def clutter_proc(self): try: from gi.repository import Clutter, GObject, Gtk, GtkClutter # explicit init seems to avoid strange thread sync/blocking issues GObject.threads_init() GtkClutter.init([]) # create main window from mfp.gui.patch_window import PatchWindow self.appwin = PatchWindow() self.mfp = MFPCommand() except Exception as e: log.error("Fatal error during GUI startup") log.debug_traceback() return try: # direct logging to GUI log console Gtk.main() except Exception as e: log.error("Caught GUI exception:", e) log.debug_traceback() sys.stdout.flush()
def dispatch_rpcdata(self, rpc_worker, rpcdata): try: json_data, peer_id = rpcdata obj = json.loads(json_data, object_hook=extended_decoder_hook) except Exception as e: log.error("Can't parse JSON for peer:", peer_id, json_data) log.debug_traceback() return True req = Request.from_dict(obj) # is someone waiting on this response? rpc_worker.data = "Request %s started" % req.request_id if req.is_response() and req.request_id in self.pending: rpc_worker.data = "Request %s processing response" % req.request_id oldreq = self.pending.get(req.request_id) del self.pending[req.request_id] oldreq.result = req.result oldreq.state = req.state oldreq.diagnostic = req.diagnostic with self.lock: self.condition.notify() elif req.is_request(): rpc_worker.data = "Request %s calling local %s (%s)" % ( req.request_id, req.method, req.params) # actually call the local handler self.handle_request(req, peer_id) # and send back the response rpc_worker.data = "Request %s sending response" % req.request_id if req.request_id is not None: self.put(req, peer_id) rpc_worker.data = "Request %s done (%s)" % (req.request_id, req.method) return True
def remove(self, obj): try: if obj.scope is not None and obj.name is not None: self.unbind(obj.name, obj.scope) del self.objects[obj.obj_id] except KeyError: log.error("Error deleting obj", obj, "can't find key", obj.obj_id) log.debug_traceback() try: self.inlet_objects.remove(obj) self.dsp_inlets = [ p[0] for p in enumerate(self.inlet_objects) if p[1] and p[1].init_type == 'inlet~' ] self.gui_params['dsp_inlets'] = self.dsp_inlets except ValueError: pass try: self.outlet_objects.remove(obj) self.dsp_outlets = [ p[0] for p in enumerate(self.outlet_objects) if p[1] and p[1].init_type == 'outlet~' ] self.gui_params['dsp_outlets'] = self.dsp_outlets except ValueError: pass try: self.dispatch_objects.remove(obj) except ValueError: pass
def dispatch_rpcdata(self, rpc_worker, rpcdata): try: json_data, peer_id = rpcdata obj = json.loads(json_data, object_hook=extended_decoder_hook) except Exception as e: log.error("Can't parse JSON for peer:", peer_id, json_data) log.debug_traceback() return True req = Request.from_dict(obj) # is someone waiting on this response? rpc_worker.data = "Request %s started" % req.request_id if req.is_response() and req.request_id in self.pending: rpc_worker.data = "Request %s processing response" % req.request_id oldreq = self.pending.get(req.request_id) del self.pending[req.request_id] oldreq.result = req.result oldreq.state = req.state oldreq.diagnostic = req.diagnostic with self.lock: self.condition.notify() elif req.is_request(): rpc_worker.data = "Request %s calling local %s (%s)" % (req.request_id, req.method, req.params) # actually call the local handler self.handle_request(req, peer_id) # and send back the response rpc_worker.data = "Request %s sending response" % req.request_id if req.request_id is not None: self.put(req, peer_id) rpc_worker.data = "Request %s done (%s)" % (req.request_id, req.method) return True
def handler(stage, event): try: return self.input_mgr.handle_event(stage, event) except Exception as e: log.error("Error handling UI event", event) log.debug(e) log.debug_traceback() return False
def grab_handler(stage, event): try: if not self.embed.has_focus(): self.embed.grab_focus() return self.input_mgr.handle_event(stage, event) except Exception, e: import traceback log.error("Error handling UI event", event) log.debug(e) traceback.print_exc() return False
def _run_onload(self, objects): from .mfp_app import MFPApp for phase in (0,1): for obj in objects: try: if obj.do_onload: obj.onload(phase) except Exception as e: log.error("Problem initializing %s.%s" % (obj.scope.name, obj.name)) log.debug_traceback() self.update_export_bounds() if MFPApp().gui_command: MFPApp().gui_command.load_complete() return True
def get_color(self, colorspec): rgba = None if self.selected: rgba = self.get_style(colorspec + ':selected') if not rgba: rgba = self.get_style(colorspec) if not rgba: rgba = self.get_style(colorspec.split(':')[0]) if not rgba: log.error('Could not find color %s in %s' % (colorspec, self._all_styles)) return ColorDB().find(64, 64, 64, 255) elif isinstance(rgba, str): return ColorDB().find(rgba) else: return ColorDB().find(rgba[0], rgba[1], rgba[2], rgba[3])
def grab_handler(stage, event): try: r = self.input_mgr.handle_event(stage, event) if not self.embed.has_focus(): log.debug("event handler: do not have focus") if hasattr(event, 'keyval'): log.debug("keyval was", event.keyval) else: log.debug("event was:", event.type) self.grab_focus() return False return r except Exception, e: import traceback log.error("Error handling UI event", event) log.debug(e) log.debug_traceback() return False
def grab_handler(stage, event): try: r = self.input_mgr.handle_event(stage, event) if not self.embed.has_focus(): log.debug("event handler: do not have focus") if hasattr(event, 'keyval'): log.debug("keyval was", event.keyval) else: log.debug("event was:", event.type) self.grab_focus() return False return r except Exception as e: import traceback log.error("Error handling UI event", event) log.debug(e) log.debug_traceback() return False
def _resize_cb(self, widget, rect): try: self.stage.set_size(rect.width, rect.height) if self.hud_mode_txt: self.hud_mode_txt.set_position(self.stage.get_width()-80, self.stage.get_height()-25) if self.hud_prompt: self.hud_prompt.set_position(10, self.stage.get_height() - 25) if self.hud_prompt_input: self.hud_prompt_input.set_position(15 + self.hud_prompt.get_width(), self.stage.get_height() - 25) except Exception as e: log.error("Error handling UI event", event) log.debug(e) log.debug_traceback() return False
def _resize_cb(self, widget, rect): try: self.stage.set_size(rect.width, rect.height) if self.hud_mode_txt: self.hud_mode_txt.set_position(self.stage.get_width() - 80, self.stage.get_height() - 25) if self.hud_prompt: self.hud_prompt.set_position(10, self.stage.get_height() - 25) if self.hud_prompt_input: self.hud_prompt_input.set_position( 15 + self.hud_prompt.get_width(), self.stage.get_height() - 25) except Exception as e: log.error("Error handling UI event", event) log.debug(e) log.debug_traceback() return False
def run(self): from mfp import log while not self.join_req: try: if self.process: fileobj = self.process.stdout r, w, e = select.select([fileobj], [], [], 0.25) if fileobj in r: ll = fileobj.readline().decode() else: continue else: ll = None if not ll: self.join_req = True else: ll = ll.strip() if ll.startswith("[LOG] "): ll = ll[6:] if ll.startswith("FATAL:"): log.error(ll[7:], module=self.log_module) self.join_req = True elif ll.startswith("ERROR:"): log.error(ll[7:], module=self.log_module) elif ll.startswith("WARNING:"): log.warning(ll[9:], module=self.log_module) elif ll.startswith("INFO:"): log.info(ll[6:], module=self.log_module) elif ll.startswith("DEBUG:"): log.debug(ll[7:], module=self.log_module) elif ll.startswith("JackEngine::XRun"): log.warning("JACK: " + ll, module=self.log_module) elif ll.startswith("JackAudioDriver"): if "Process error" in ll: log.error("JACK: " + ll, module=self.log_module) elif self.log_raw and len(ll): log.debug("%s " % self.log_module, ll) except Exception as e: log.debug("RPCExecRemote: exiting with error", e) self.join_req = True if self.process: self.process.terminate() self.process.wait()
def run(self): from mfp import log while not self.join_req: try: if self.process: ll = self.process.stdout.readline() else: ll = None if not ll: self.join_req = True else: ll = ll.strip() if self.log_raw: log.debug("%s:" % self.log_module, ll.strip()) if ll.startswith("[LOG] "): ll = ll[6:] if ll.startswith("FATAL:"): log.error(ll[7:], module=self.log_module) self.join_req = True elif ll.startswith("ERROR:"): log.error(ll[7:], module=self.log_module) elif ll.startswith("WARNING:"): log.warning(ll[9:], module=self.log_module) elif ll.startswith("INFO:"): log.info(ll[6:], module=self.log_module) elif ll.startswith("DEBUG:"): log.debug(ll[7:], module=self.log_module) elif ll.startswith("JackEngine::XRun"): log.warning("JACK: " + ll, module=self.log_module) elif ll.startswith("JackAudioDriver"): if "Process error" in ll: log.error("JACK: " + ll, module=self.log_module) except Exception, e: print "RPCExecRemote caught error:", e log.debug("RPCExecRemote: exiting") self.join_req = True
def run(self): ''' RPCHost.run: perform IO on managed sockets, dispatch data ''' self.read_workers.start() if RPCWrapper.rpchost is None: RPCWrapper.rpchost = self import select self.fdsockets = {} while not self.join_req: rdy = None for s in self.managed_sockets.values(): if s.fileno() not in self.fdsockets: self.fdsockets[s.fileno()] = s try: sockets = list(self.fdsockets.keys()) if sockets: rdy, _w, _x = select.select(list(self.fdsockets.keys()), [], [], 0.1) else: time.sleep(0.1) except Exception as e: print("select exception:", e) if not rdy: continue syncbytes = 8 sync = b'' for rsock in rdy: jdata = b'' retry = 1 while retry: sock = self.fdsockets.get(rsock) if sock is None: retry = 0 jdata = None continue try: sync = sync[syncbytes:] syncbit = sock.recv(syncbytes) if not syncbit: raise self.RecvError() sync += syncbit if sync != RPCHost.SYNC_MAGIC: syncbytes = 1 retry = 1 raise self.SyncError() else: syncbytes = 8 retry = 0 jlen = sock.recv(8) jlen = int(jlen) recvlen = 0 while recvlen < jlen: jdata += sock.recv(jlen - recvlen) recvlen = len(jdata) if recvlen < jlen: log.warning( "RPCHost: got short packet (%d of %d)" % (recvlen, jlen)) except RPCHost.SyncError as e: log.warning("RPCHost: sync error, resyncing") pass except (socket.error, RPCHost.RecvError) as e: log.warning("RPCHost: communication error") retry = 0 jdata = None deadpeer = self.peers_by_socket[sock] self.unmanage(deadpeer) except Exception as e: log.error("RPCHost: unhandled exception", type(e), e) log.debug(jdata) log.debug_traceback() retry = 0 jdata = b"" if jdata is not None and len(jdata) >= jlen: peer_id = self.peers_by_socket.get(sock) self.read_workers.submit((jdata, peer_id)) if self.node_id == 0: peers = list(self.managed_sockets.keys()) for node in peers: req = Request("exit_request", {}) self.put(req, node) self.wait(req) del self.managed_sockets[node] elif 0 in self.managed_sockets: req = Request("exit_notify", {}) self.put(req, 0) self.wait(req) for clsname, cls in list(self.served_classes.items()): self.unpublish(cls) for clsname, cls in RPCWrapper.rpctype.items(): cls.publishers = [] if RPCWrapper.rpchost == self: RPCWrapper.rpchost = None self.read_workers.finish()
def run(self): ''' RPCHost.run: perform IO on managed sockets, dispatch data ''' self.read_workers.start() if RPCWrapper.rpchost is None: RPCWrapper.rpchost = self import select self.fdsockets = {} while not self.join_req: rdy = None for s in self.managed_sockets.values(): if s.fileno() not in self.fdsockets: self.fdsockets[s.fileno()] = s try: sockets = list(self.fdsockets.keys()) if sockets: rdy, _w, _x = select.select(list(self.fdsockets.keys()), [], [], 0.1) else: time.sleep(0.1) except Exception as e: print("select exception:", e) if not rdy: continue syncbytes = 8 sync = b'' for rsock in rdy: jdata = b'' retry = 1 while retry: sock = self.fdsockets.get(rsock) if sock is None: retry = 0 jdata = None continue try: sync = sync[syncbytes:] syncbit = sock.recv(syncbytes) if not syncbit: raise self.RecvError() sync += syncbit if sync != RPCHost.SYNC_MAGIC: syncbytes = 1 retry = 1 raise self.SyncError() else: syncbytes = 8 retry = 0 jlen = sock.recv(8) jlen = int(jlen) recvlen = 0 while recvlen < jlen: jdata += sock.recv(jlen-recvlen) recvlen = len(jdata) if recvlen < jlen: log.warning("RPCHost: got short packet (%d of %d)" % (recvlen, jlen)) except RPCHost.SyncError as e: log.warning("RPCHost: sync error, resyncing") pass except (socket.error, RPCHost.RecvError) as e: log.warning("RPCHost: communication error") retry = 0 jdata = None deadpeer = self.peers_by_socket[sock] self.unmanage(deadpeer) except Exception as e: log.error("RPCHost: unhandled exception", type(e), e) log.debug(jdata) log.debug_traceback() retry = 0 jdata = b"" if jdata is not None and len(jdata) >= jlen: peer_id = self.peers_by_socket.get(sock) self.read_workers.submit((jdata, peer_id)) if self.node_id == 0: peers = list(self.managed_sockets.keys()) for node in peers: req = Request("exit_request", {}) self.put(req, node) self.wait(req) del self.managed_sockets[node] elif 0 in self.managed_sockets: req = Request("exit_notify", {}) self.put(req, 0) self.wait(req) for clsname, cls in list(self.served_classes.items()): self.unpublish(cls) for clsname, cls in RPCWrapper.rpctype.items(): cls.publishers = [] if RPCWrapper.rpchost == self: RPCWrapper.rpchost = None self.read_workers.finish()
def run(self): ''' RPCHost.run: perform IO on managed sockets, dispatch data ''' self.read_workers.start() if RPCWrapper.rpchost is None: RPCWrapper.rpchost = self import select self.fdsockets = {} while not self.join_req: rdy = None for s in self.managed_sockets.values(): if s.fileno() not in self.fdsockets: self.fdsockets[s.fileno()] = s try: sockets = self.fdsockets.keys() if sockets: rdy, _w, _x = select.select(self.fdsockets.keys(), [], [], 0.1) else: time.sleep(0.1) except Exception, e: print "select exception:", e if not rdy: continue syncbytes = 8 sync = '' for rsock in rdy: jdata = '' retry = 1 while retry: sock = self.fdsockets.get(rsock) if sock is None: retry = 0 jdata = None continue try: sync = sync[syncbytes:] syncbit = sock.recv(syncbytes) if not syncbit: raise self.RecvError() sync += syncbit if sync != RPCHost.SYNC_MAGIC: syncbytes = 1 retry = 1 raise self.SyncError() else: syncbytes = 8 retry = 0 jlen = sock.recv(8) jlen = int(jlen) recvlen = 0 while recvlen < jlen: jdata += sock.recv(jlen-recvlen) recvlen = len(jdata) if recvlen < jlen: log.warning("RPCHost: got short packet (%d of %d)" % (recvlen, jlen)) except RPCHost.SyncError, e: log.warning("RPCHost: sync error, resyncing") pass except (socket.error, RPCHost.RecvError) as e: log.warning("RPCHost: communication error") retry = 0 jdata = None deadpeer = self.peers_by_socket[sock] self.unmanage(deadpeer) except Exception, e: log.error("RPCHost: unhandled exception", type(e), e) log.debug(jdata) log.debug_traceback() retry = 0 jdata = ""
def handle_event(self, stage, event): from gi.repository import Clutter from mfp import log keysym = None if event.type in ( Clutter.EventType.KEY_PRESS, Clutter.EventType.KEY_RELEASE, Clutter.EventType.BUTTON_PRESS, Clutter.EventType.BUTTON_RELEASE, Clutter.EventType.SCROLL): self.keyseq.process(event) if len(self.keyseq.sequences): keysym = self.keyseq.pop() elif event.type == Clutter.EventType.MOTION: # FIXME: if the scaling changes so that window.stage_pos would return a # different value, that should generate a MOTION event. Currently we are # just kludging pointer_x and pointer_y from the scale callback. self.pointer_ev_x = event.x self.pointer_ev_y = event.y self.pointer_x, self.pointer_y = self.window.stage_pos(event.x, event.y) self.keyseq.process(event) if len(self.keyseq.sequences): keysym = self.keyseq.pop() elif event.type == Clutter.EventType.ENTER: src = self.event_sources.get(event.source) now = datetime.now() if (self.pointer_leave_time is not None and (now - self.pointer_leave_time) > timedelta(milliseconds=100)): self.keyseq.mod_keys = set() self.window.grab_focus() if src and self.window.object_visible(src): self.pointer_obj = src self.pointer_obj_time = now elif event.type == Clutter.EventType.LEAVE: src = self.event_sources.get(event.source) self.pointer_leave_time = datetime.now() if src == self.pointer_obj: self.pointer_lastobj = self.pointer_obj self.pointer_obj = None self.pointer_obj_time = None else: log.debug("event type not matched:", event.type) return False if not keysym: return True retry_count = 0 while True: rv = None try: retry_count += 1 rv = self.handle_keysym(keysym) except self.InputNeedsRequeue, e: if retry_count < 5: continue else: return False except Exception, e: log.error("Exception while handling key command", keysym) log.debug(e) log.debug_traceback()
def handle_event(self, stage, event): from gi.repository import Clutter keysym = None if event.type in (Clutter.EventType.KEY_PRESS, Clutter.EventType.KEY_RELEASE, Clutter.EventType.BUTTON_PRESS, Clutter.EventType.BUTTON_RELEASE, Clutter.EventType.SCROLL): self.keyseq.process(event) if len(self.keyseq.sequences): keysym = self.keyseq.pop() elif event.type == Clutter.EventType.MOTION: # FIXME: if the scaling changes so that window.stage_pos would return a # different value, that should generate a MOTION event. Currently we are # just kludging pointer_x and pointer_y from the scale callback. self.pointer_ev_x = event.x self.pointer_ev_y = event.y self.pointer_x, self.pointer_y = self.window.stage_pos( event.x, event.y) self.keyseq.process(event) if len(self.keyseq.sequences): keysym = self.keyseq.pop() elif event.type == Clutter.EventType.ENTER: src = self.event_sources.get(event.source) now = datetime.now() if (self.pointer_leave_time is not None and (now - self.pointer_leave_time) > timedelta(milliseconds=100)): self.keyseq.mod_keys = set() self.window.embed.grab_focus() if src and self.window.object_visible(src): self.pointer_obj = src self.pointer_obj_time = now elif event.type == Clutter.EventType.LEAVE: src = self.event_sources.get(event.source) self.pointer_leave_time = datetime.now() if src == self.pointer_obj: self.pointer_lastobj = self.pointer_obj self.pointer_obj = None self.pointer_obj_time = None else: return False retry_count = 0 while True: rv = None try: retry_count += 1 rv = self.handle_keysym(keysym) except self.InputNeedsRequeue, e: if retry_count < 5: continue else: return False except Exception, e: from mfp import log import traceback log.error("Exception while handling key command", keysym) for l in traceback.format_exc().split("\n"): log.debug(l) log.debug(e)