Commits

Alessio Deiana  committed 578c0f4

updated .push calls to .fire calls

  • Participants
  • Parent commits 6d730c0

Comments (0)

Files changed (58)

File circuits/app/daemon.py

         os.dup2(so.fileno(), sys.stdout.fileno())
         os.dup2(se.fileno(), sys.stderr.fileno())
 
-        self.push(WritePID())
+        self.fire(WritePID())
 
     @handler("started", filter=True, priority=100.0, target="*")
     def _on_started(self, manager, mode):
         if not manager == self and mode is None:
-            self.push(Daemonize())
+            self.fire(Daemonize())
 
     @handler("registered")
     def _on_registered(self, component, manager):
         if component == self and manager == self and manager.root.running:
-            self.push(Daemonize())
+            self.fire(Daemonize())

File circuits/app/env.py

     @handler("load", priority=1.0)
     def load(self, verify=False):
         if verify:
-            return self.push(Verify())
+            return self.fire(Verify())
         else:
             return self._load()
 
                         "path": self.path,
                     }
                 self.config.set(section, option, value)
-        return self.push(config.Save(), target=self.config)
+        return self.fire(config.Save(), target=self.config)
 
     def _load(self):
         # Create Config Component
         configfile = joinpath(self.path, "conf", "%s.ini" % self.envname)
         self.config = Config(configfile).register(self)
-        self.push(config.Load(), target=self.config)
+        self.fire(config.Load(), target=self.config)
         return True

File circuits/app/startup.py

     @handler("signal", target="*")
     def _on_signal(self, signal, track):
         if signal in (SIGINT, SIGTERM):
-            self.push(Terminate())
+            self.fire(Terminate())
 
     @handler("environment_loaded", target="env")
     def _on_environment_loaded(self, *args):
-        self.push(Command(), self.command, self)
+        self.fire(Command(), self.command, self)
 
     @handler("started")
     def _on_started(self, component, mode):
             if not os.path.exists(self.env.path):
                 raise Error("Environment does not exist!")
             else:
-                self.push(LoadEnvironment(), target=self.env)
+                self.fire(LoadEnvironment(), target=self.env)
         else:
             if os.path.exists(self.env.path):
                 raise Error("Environment already exists!")
             else:
-                self.push(Command(), self.command, self)
+                self.fire(Command(), self.command, self)
 
     @handler("start")
     def _on_start(self):
 
     @handler("restart")
     def _on_restart(self):
-        self.push(Command(), "stop", self.channel)
+        self.fire(Command(), "stop", self.channel)
         sleep(1)
-        self.push(Command(), "start", self.channel)
+        self.fire(Command(), "start", self.channel)
 
     @handler("rehash")
     def _on_rehash(self):
 
     @handler("init")
     def _on_init(self):
-        self.push(CreateEnvironment(), target=self.env)
+        self.fire(CreateEnvironment(), target=self.env)
 
     @handler("upgrade")
     def _on_upgrade(self):
-        self.push(UpgradeEnvironment(), target=self.env)
+        self.fire(UpgradeEnvironment(), target=self.env)

File circuits/core/bridge.py

         try:
             eid = self._values[value]
             s = dumps((eid, value), -1)
-            self.push(Write(s), target=self._socket)
+            self.fire(Write(s), target=self._socket)
         except:
             return
 
     def _process(self, id, obj):
         if isinstance(obj, Event):
             obj.remote = True
-            value = self._manager.push(obj)
+            value = self._manager.fire(obj)
             self._values[value] = id
             value.manager = self._manager
             value.onSet = "value",
             eid = id(event)
             self._values[eid] = event.value
             s = dumps((eid, event))
-            self.push(Write(s), target=self._socket)
+            self.fire(Write(s), target=self._socket)
         except:
             return
 

File circuits/core/futures.py

                 p = findcmp(self.root, Pool)
             if p is not None:
                 setattr(self, "_pool", p)
-                return self.push(Task(f, self, *args, **kwargs), target=p)
+                return self.fire(Task(f, self, *args, **kwargs), target=p)
             else:
-                return Worker(channel=str(uuid())).push(
+                return Worker(channel=str(uuid())).fire(
                         Task(f, self, *args, **kwargs))
         wrapper.event = True
         return update_wrapper(wrapper, f)

File circuits/core/pollers.py

 
         for sock in w:
             if self.isWriting(sock):
-                self.push(Write(sock), "_write", self.getTarget(sock))
+                self.fire(Write(sock), "_write", self.getTarget(sock))
 
         for sock in r:
             if self.isReading(sock):
-                self.push(Read(sock), "_read", self.getTarget(sock))
+                self.fire(Read(sock), "_read", self.getTarget(sock))
 
 
 class Poll(BasePoller):
         fd = self._map[fileno]
 
         if event & self._disconnected_flag and not (event & select.POLLIN):
-            self.push(Disconnect(fd), "_disconnect", self.getTarget(fd))
+            self.fire(Disconnect(fd), "_disconnect", self.getTarget(fd))
             self._poller.unregister(fileno)
             super(Poll, self).discard(fd)
             del self._map[fileno]
         else:
             try:
                 if event & select.POLLIN:
-                    self.push(Read(fd), "_read", self.getTarget(fd))
+                    self.fire(Read(fd), "_read", self.getTarget(fd))
                 if event & select.POLLOUT:
-                    self.push(Write(fd), "_write", self.getTarget(fd))
+                    self.fire(Write(fd), "_write", self.getTarget(fd))
             except Exception as e:
-                self.push(Error(fd, e), "_error", self.getTarget(fd))
-                self.push(Disconnect(fd), "_disconnect", self.getTarget(fd))
+                self.fire(Error(fd, e), "_error", self.getTarget(fd))
+                self.fire(Disconnect(fd), "_disconnect", self.getTarget(fd))
                 self._poller.unregister(fileno)
                 super(Poll, self).discard(fd)
                 del self._map[fileno]
         fd = self._map[fileno]
 
         if event & self._disconnected_flag and not (event & select.POLLIN):
-            self.push(Disconnect(fd), "_disconnect", self.getTarget(fd))
+            self.fire(Disconnect(fd), "_disconnect", self.getTarget(fd))
             self._poller.unregister(fileno)
             super(EPoll, self).discard(fd)
             del self._map[fileno]
         else:
             try:
                 if event & select.EPOLLIN:
-                    self.push(Read(fd), "_read", self.getTarget(fd))
+                    self.fire(Read(fd), "_read", self.getTarget(fd))
                 if event & select.EPOLLOUT:
-                    self.push(Write(fd), "_write", self.getTarget(fd))
+                    self.fire(Write(fd), "_write", self.getTarget(fd))
             except Exception as e:
-                self.push(Error(fd, e), "_error", self.getTarget(fd))
-                self.push(Disconnect(fd), "_disconnect", self.getTarget(fd))
+                self.fire(Error(fd, e), "_error", self.getTarget(fd))
+                self.fire(Disconnect(fd), "_disconnect", self.getTarget(fd))
                 self._poller.unregister(fileno)
                 super(EPoll, self).discard(fd)
                 del self._map[fileno]
         sock = self._map[event.ident]
 
         if event.flags & select.KQ_EV_ERROR:
-            self.push(Error(sock, "error"), "_error", self.getTarget(sock))
+            self.fire(Error(sock, "error"), "_error", self.getTarget(sock))
         elif event.flags & select.KQ_EV_EOF:
-            self.push(Disconnect(sock), "_disconnect", self.getTarget(sock))
+            self.fire(Disconnect(sock), "_disconnect", self.getTarget(sock))
         elif event.filter == select.KQ_FILTER_WRITE:
-            self.push(Write(sock), "_write", self.getTarget(sock))
+            self.fire(Write(sock), "_write", self.getTarget(sock))
         elif event.filter == select.KQ_FILTER_READ:
-            self.push(Read(sock), "_read", self.getTarget(sock))
+            self.fire(Read(sock), "_read", self.getTarget(sock))
 
 Poller = Select
 

File circuits/core/pools.py

         if not assigned:
             worker = choice(self._workers)
             assigned = worker.channel
-            return worker.push(Task(f, *args, **kwargs), target=worker)
+            return worker.fire(Task(f, *args, **kwargs), target=worker)

File circuits/core/timers.py

 
     def __tick__(self):
         if time() > self._eTime:
-            self.push(self.e, self.c, self.t)
+            self.fire(self.e, self.c, self.t)
 
             if self.persist:
                 self.reset()

File circuits/io/file.py

         if any([m for m in "r+" if m in self._fd.mode]):
             self._read.append(self._fd)
 
-        self.push(Opened(self.filename), "opened")
+        self.fire(Opened(self.filename), "opened")
 
     @property
     def closed(self):
                 r, w, e = select.select(self._read, self._write, [], wait)
             except select.error as error:
                 if not error[0] == errno.EINTR:
-                    self.push(Error(error), "error")
+                    self.fire(Error(error), "error")
                 return
 
             if w and self._buffer:
                     elif not self._buffer:
                         self._write.remove(self._fd)
                 except OSError as error:
-                    self.push(Error(error), "error")
+                    self.fire(Error(error), "error")
 
             if r:
                 try:
                         data = None
 
                 if data:
-                    self.push(Read(data), "read")
+                    self.fire(Read(data), "read")
                 elif self.autoclose:
-                    self.push(EOF())
+                    self.fire(EOF())
                     self.close()
 
     def write(self, data):
         self._fd.close()
         self._read = []
         self._write = []
-        self.push(Closed(self.filename), "closed")
+        self.fire(Closed(self.filename), "closed")
 
     def seek(self, offset, whence=0):
         self._fd.seek(offset, whence)

File circuits/io/notify.py

             if mask & k:
                 e = v(name, path, pathname, dir)
                 c = e.name.lower()
-                self.push(e, c)
+                self.fire(e, c)
 
     def add_path(self, path, mask=None, recursive=False):
         mask = mask or MASK

File circuits/io/serial.py

 
         self._read.append(self._fd)
 
-        self.push(Opened(self.port))
+        self.fire(Opened(self.port))
 
     def __tick__(self):
         r, w, e = select.select(self._read, self._write, [], self._timeout)
                     if not self._buffer and self._fd in self._write:
                         self._write.remove(self._fd)
             except OSError as error:
-                self.push(Error(error))
+                self.fire(Error(error))
 
         if r:
             data = os.read(self._fd, self._bufsize)
             if data:
-                self.push(Read(data))
+                self.fire(Read(data))
 
     def write(self, data):
         if self._fd not in self._write:
         self._read = []
         self._write = []
         self._serial.close()
-        self.push(Closed(self.port))
+        self.fire(Closed(self.port))

File circuits/net/protocols/http.py

             cLen = int(self._response.headers.get("Content-Length", "0"))
             if cLen and self._response._body.tell() == cLen:
                 self._response._body.seek(0)
-                self.push(Response(self._response))
+                self.fire(Response(self._response))
                 self._response = None
         else:
             statusline, data = data.split(b"\r\n", 1)
                 return
 
             response._body.seek(0)
-            self.push(Response(response))
+            self.fire(Response(response))

File circuits/net/protocols/irc.py

     ###
 
     def RAW(self, data):
-        self.push(Write("%s\r\n" % data))
+        self.fire(Write("%s\r\n" % data))
 
     def PASS(self, password):
-        self.push(RAW("PASS %s" % password))
+        self.fire(RAW("PASS %s" % password))
 
     def USER(self, ident, host, server, name):
-        self.push(RAW("USER %s \"%s\" \"%s\" :%s" % (
+        self.fire(RAW("USER %s \"%s\" \"%s\" :%s" % (
             ident, host, server, name)))
 
     def NICK(self, nick):
-        self.push(RAW("NICK %s" % nick))
+        self.fire(RAW("NICK %s" % nick))
 
     def PING(self, server):
-        self.push(RAW("PING :%s" % server))
+        self.fire(RAW("PING :%s" % server))
 
     def PONG(self, server):
-        self.push(RAW("PONG :%s" % server))
+        self.fire(RAW("PONG :%s" % server))
 
     def QUIT(self, message="Leaving"):
-        self.push(RAW("QUIT :%s" % message))
+        self.fire(RAW("QUIT :%s" % message))
 
     def JOIN(self, channel, key=None):
         if key is None:
-            self.push(RAW("JOIN %s" % channel))
+            self.fire(RAW("JOIN %s" % channel))
         else:
-            self.push(RAW("JOIN %s %s" % (channel, key)))
+            self.fire(RAW("JOIN %s %s" % (channel, key)))
 
     def PART(self, channel, message="Leaving"):
-        self.push(RAW("PART %s :%s" % (channel, message)))
+        self.fire(RAW("PART %s :%s" % (channel, message)))
 
     def PRIVMSG(self, target, message):
-        self.push(RAW("PRIVMSG %s :%s" % (target, message)))
+        self.fire(RAW("PRIVMSG %s :%s" % (target, message)))
 
     def NOTICE(self, target, message):
-        self.push(RAW("NOTICE %s :%s" % (target, message)))
+        self.fire(RAW("NOTICE %s :%s" % (target, message)))
 
     def CTCP(self, target, type, message):
-        self.push(PRIVMSG(target, "%s %s" % (type, message)))
+        self.fire(PRIVMSG(target, "%s %s" % (type, message)))
 
     def CTCPREPLY(self, target, type, message):
-        self.push(NOTICE(target, "%s %s" % (type, message)))
+        self.fire(NOTICE(target, "%s %s" % (type, message)))
 
     def KICK(self, channel, target, message=""):
-        self.push(RAW("KICK %s %s :%s" % (channel, target, message)))
+        self.fire(RAW("KICK %s %s :%s" % (channel, target, message)))
 
     def TOPIC(self, channel, topic):
-        self.push(RAW("TOPIC %s :%s" % (channel, topic)))
+        self.fire(RAW("TOPIC %s :%s" % (channel, topic)))
 
     def MODE(self, modes, channel=None):
         if channel is None:
-            self.push(RAW("MODE :%s" % modes))
+            self.fire(RAW("MODE :%s" % modes))
         else:
-            self.push(RAW("MODE %s :%s" % (channel, modes)))
+            self.fire(RAW("MODE %s :%s" % (channel, modes)))
 
     def INVITE(self, target, channel):
-        self.push(RAW("INVITE %s %s" % (target, channel)))
+        self.fire(RAW("INVITE %s %s" % (target, channel)))
 
     def NAMES(self, channel=None):
         if channel:
-            self.push(RAW("NAMES %s" % channel))
+            self.fire(RAW("NAMES %s" % channel))
         else:
-            self.push(RAW("NAMES"))
+            self.fire(RAW("NAMES"))
 
     ###
     ### Event Processing
         tokens = line.split(" ")
 
         if tokens[0] == "PING":
-            self.push(Ping(strip(tokens[1])))
+            self.fire(Ping(strip(tokens[1])))
 
         elif re.match("[0-9]+", tokens[1]):
             source = strip(tokens[0])
                 arg = tokens[3]
                 message = strip(" ".join(tokens[4:]))
 
-            self.push(Numeric(source, target, numeric, arg, message))
+            self.fire(Numeric(source, target, numeric, arg, message))
 
         elif tokens[1] == "PRIVMSG":
             source = sourceSplit(strip(tokens[0]))
                 tokens = strip(message, color=True).split(" ")
                 type = tokens[0]
                 message = " ".join(tokens[1:])
-                self.push(Ctcp(source, target, type, message))
+                self.fire(Ctcp(source, target, type, message))
             else:
-                self.push(Message(source, target, message))
+                self.fire(Message(source, target, message))
 
         elif tokens[1] == "NOTICE":
             source = sourceSplit(strip(tokens[0]))
             target = tokens[2]
             message = strip(" ".join(tokens[3:]))
-            self.push(Notice(source, target, message))
+            self.fire(Notice(source, target, message))
 
         elif tokens[1] == "JOIN":
             source = sourceSplit(strip(tokens[0]))
             channel = strip(tokens[2])
-            self.push(Join(source, channel))
+            self.fire(Join(source, channel))
 
         elif tokens[1] == "PART":
             source = sourceSplit(strip(tokens[0]))
             channel = strip(tokens[2])
             message = strip(" ".join(tokens[3:]))
-            self.push(Part(source, channel, message))
+            self.fire(Part(source, channel, message))
 
         elif tokens[1] == "QUIT":
             source = sourceSplit(strip(tokens[0]))
             message = strip(" ".join(tokens[2:]))
-            self.push(Quit(source, message))
+            self.fire(Quit(source, message))
 
         elif tokens[1] == "NICK":
             source = sourceSplit(strip(tokens[0]))
             newNick = strip(tokens[2])
 
-            self.push(Nick(source, newNick))
+            self.fire(Nick(source, newNick))
 
         elif tokens[1] == "MODE":
             source = sourceSplit(strip(tokens[0]))
             target = tokens[2]
             modes = strip(" ".join(tokens[3:]))
-            self.push(Mode(source, target, modes))
+            self.fire(Mode(source, target, modes))
 
     ###
     ### Default Events
         or sending your own Pong reponse.
         """
 
-        self.push(PONG(server))
+        self.fire(PONG(server))
 
 ###
 ### Errors and Numeric Replies

File circuits/net/protocols/line.py

             data, = args
             lines, self.buffer = self.splitter(data, self.buffer)
             for line in lines:
-                self.push(Line(line.decode(self.encoding, "replace")))
+                self.fire(Line(line.decode(self.encoding, "replace")))
         else:
             # Server read
             sock, data = args
             lines, buffer = self.splitter(data, self.getBuffer(sock))
             self.updateBuffer(sock, buffer)
             for line in lines:
-                self.push(Line(sock,
+                self.fire(Line(sock,
                     line.decode(self.encoding, "replace")))

File circuits/net/sockets.py

         if self._poller is None:
             if isinstance(component, BasePoller):
                 self._poller = component
-                self.push(Ready(self), "ready", self.channel)
+                self.fire(Ready(self), "ready", self.channel)
             else:
                 component = findcmp(self.root, BasePoller, subclass=False)
                 if component is not None:
                     self._poller = component
-                    self.push(Ready(self), "ready", self.channel)
+                    self.fire(Ready(self), "ready", self.channel)
                 else:
                     self._poller = Poller().register(self)
-                    self.push(Ready(self), "ready", self.channel)
+                    self.fire(Ready(self), "ready", self.channel)
 
     @handler("started", filter=True, target="*")
     def _on_started(self, component, mode):
         if self._poller is None:
             self._poller = Poller().register(self)
-            self.push(Ready(self), "ready", self.channel)
+            self.fire(Ready(self), "ready", self.channel)
             return True
 
     @handler("stopped", target="*")
     def _on_stopped(self, component):
-        self.push(Close(), "close", self.channel)
+        self.fire(Close(), "close", self.channel)
 
     def _close(self):
         if not self._connected:
         except SocketError:
             pass
 
-        self.push(Disconnected(), "disconnected", self.channel)
+        self.fire(Disconnected(), "disconnected", self.channel)
 
     def close(self):
         if not self._buffer:
                 data = self._sock.recv(self._bufsize)
 
             if data:
-                self.push(Read(data), "read", self.channel)
+                self.fire(Read(data), "read", self.channel)
             else:
                 self.close()
         except SocketError as e:
             if e.args[0] == EWOULDBLOCK:
                 return
             else:
-                self.push(Error(e), "error", self.channel)
+                self.fire(Error(e), "error", self.channel)
                 self._close()
 
     def _write(self, data):
             if e.args[0] in (EPIPE, ENOTCONN):
                 self._close()
             else:
-                self.push(Error(e), "error", self.channel)
+                self.fire(Error(e), "error", self.channel)
 
     def write(self, data):
         if not self._poller.isWriting(self._sock):
             if r in (EISCONN, EWOULDBLOCK, EINPROGRESS, EALREADY):
                 self._connected = True
             else:
-                self.push(Error(r), "error", self.channel)
+                self.fire(Error(r), "error", self.channel)
                 return
 
         self._connected = True
         if self.secure:
             self._ssock = ssl_socket(self._sock, self.keyfile, self.certfile)
 
-        self.push(Connected(host, port), "connected", self.channel)
+        self.fire(Connected(host, port), "connected", self.channel)
 
 
 class UNIXClient(Client):
             if r in (EISCONN, EWOULDBLOCK, EINPROGRESS, EALREADY):
                 self._connected = True
             else:
-                self.push(Error(r), "error", self.channel)
+                self.fire(Error(r), "error", self.channel)
                 return
 
         self._connected = True
         if self.secure:
             self._ssock = ssl_socket(self._sock, self.keyfile, self.certfile)
 
-        self.push(Connected(gethostname(), path), "connected", self.channel)
+        self.fire(Connected(gethostname(), path), "connected", self.channel)
 
 
 class Server(Component):
             if isinstance(component, BasePoller):
                 self._poller = component
                 self._poller.addReader(self, self._sock)
-                self.push(Ready(self), "ready", self.channel)
+                self.fire(Ready(self), "ready", self.channel)
             else:
                 component = findcmp(self.root, BasePoller, subclass=False)
                 if component is not None:
                     self._poller = component
                     self._poller.addReader(self, self._sock)
-                    self.push(Ready(self), "ready", self.channel)
+                    self.fire(Ready(self), "ready", self.channel)
                 else:
                     self._poller = Poller().register(self)
                     self._poller.addReader(self, self._sock)
-                    self.push(Ready(self), "ready", self.channel)
+                    self.fire(Ready(self), "ready", self.channel)
 
     @handler("started", filter=True, target="*")
     def _on_started(self, component, mode):
         if self._poller is None:
             self._poller = Poller().register(self)
             self._poller.addReader(self, self._sock)
-            self.push(Ready(self), "ready", self.channel)
+            self.fire(Ready(self), "ready", self.channel)
             return True
 
     @handler("stopped", target="*")
     def _on_stopped(self, component):
-        self.push(Close(), "close", self.channel)
+        self.fire(Close(), "close", self.channel)
 
     def _close(self, sock):
         if sock is None:
         except SocketError:
             pass
 
-        self.push(Disconnect(sock), "disconnect", self.channel)
+        self.fire(Disconnect(sock), "disconnect", self.channel)
 
     def close(self, sock=None):
         closed = sock is None
                 self._closeq.append(sock)
 
         if closed:
-            self.push(Closed(), "closed", self.channel)
+            self.fire(Closed(), "closed", self.channel)
 
     def _read(self, sock):
         if sock not in self._clients:
         try:
             data = sock.recv(self._bufsize)
             if data:
-                self.push(Read(sock, data), "read", self.channel)
+                self.fire(Read(sock, data), "read", self.channel)
             else:
                 self.close(sock)
         except SocketError as e:
             if e.args[0] == EWOULDBLOCK:
                 return
             else:
-                self.push(Error(sock, e), "error", self.channel)
+                self.fire(Error(sock, e), "error", self.channel)
                 self._close(sock)
 
     def _write(self, sock, data):
                 self._buffers[sock].appendleft(data[nbytes:])
         except SocketError as e:
             if e.args[0] not in (EINTR, EWOULDBLOCK, ENOBUFS):
-                self.push(Error(sock, e), "error", self.channel)
+                self.fire(Error(sock, e), "error", self.channel)
                 self._close(sock)
             else:
                 self._buffers[sock].appendleft(data)
         newsock.setblocking(False)
         self._poller.addReader(self, newsock)
         self._clients.append(newsock)
-        self.push(Connect(newsock, *host), "connect", self.channel)
+        self.fire(Connect(newsock, *host), "connect", self.channel)
 
     @handler("_disconnect", filter=True)
     def _on_disconnect(self, sock):
         except SocketError:
             pass
 
-        self.push(Disconnect(sock), "disconnect", self.channel)
+        self.fire(Disconnect(sock), "disconnect", self.channel)
 
     @handler("close", override=True)
     def close(self):
-        self.push(Closed(), "closed", self.channel)
+        self.fire(Closed(), "closed", self.channel)
 
         if self._buffers[self._sock] and self._sock not in self._closeq:
             self._closeq.append(self._sock)
         try:
             data, address = self._sock.recvfrom(self._bufsize)
             if data:
-                self.push(Read(address, data), "read", self.channel)
+                self.fire(Read(address, data), "read", self.channel)
         except SocketError as e:
             if e.args[0] in (EWOULDBLOCK, EAGAIN):
                 return
-            self.push(Error(self._sock, e), "error", self.channel)
+            self.fire(Error(self._sock, e), "error", self.channel)
             self._close(self._sock)
 
     def _write(self, address, data):
             if e.args[0] in (EPIPE, ENOTCONN):
                 self._close(self._sock)
             else:
-                self.push(Error(self._sock, e), "error", self.channel)
+                self.fire(Error(self._sock, e), "error", self.channel)
 
     @handler("write", override=True)
     def write(self, address, data):

File circuits/web/client.py

     @handler("write")
     def write(self, data):
         if self._transport.connected:
-            self.push(Write(data), target=self._transport)
+            self.fire(Write(data), target=self._transport)
 
     @handler("close")
     def close(self):
         if self._transport.connected:
-            self.push(Close(), target=self._transport)
+            self.fire(Close(), target=self._transport)
 
     @handler("connect")
     def connect(self):
         if not self._transport.connected:
-            self.push(Connect(self._host, self._port, self._secure),
+            self.fire(Connect(self._host, self._port, self._secure),
                     target=self._transport)
 
     @handler("request")
             headers = Headers([(k, v) for k, v in headers.items()])
             command = "%s %s HTTP/1.1" % (method, path)
             message = "%s\r\n%s" % (command, headers)
-            self.push(Write(message.encode('utf-8')), target=self._transport)
+            self.fire(Write(message.encode('utf-8')), target=self._transport)
             if body:
-                self.push(Write(body), target=self._transport)
+                self.fire(Write(body), target=self._transport)
         else:
             raise NotConnected()
 
     def _on_response(self, response):
         self._response = response
         if response.headers.get("Connection") == "Close":
-            self.push(Close(), target=self._transport)
+            self.fire(Close(), target=self._transport)
 
     @property
     def connected(self):

File circuits/web/dispatchers/dispatcher.py

             if vpath:
                 req.args += tuple(vpath)
 
-            return self.push(req, channel, target)
+            return self.fire(req, channel, target)

File circuits/web/dispatchers/jsonrpc.py

         id = value.id
         response = value.response
         response.body = self._response(id, value.value)
-        self.push(Response(response), target=self.channel)
+        self.fire(Response(response), target=self.channel)
         value.handled = True
 
     @handler("request", filter=True, priority=0.1)
                 t, c = self.target, method
 
             if type(params) is dict:
-                value = self.push(RPC(**params), c, t)
+                value = self.fire(RPC(**params), c, t)
             else:
-                value = self.push(RPC(*params), c, t)
+                value = self.fire(RPC(*params), c, t)
 
             value.id = id
             value.response = response

File circuits/web/dispatchers/routes.py

             if vpath:
                 req.args += tuple(vpath)
 
-            return self.push(req, channel, target=target)
+            return self.fire(req, channel, target=target)
 
     @handler("registered", target="*")
     def _on_registered(self, event, component, manager):

File circuits/web/dispatchers/websockets.py

     @handler("write", target=WebSocketEvent._target)
     def _on_write(self, sock, data):
         payload = b'\x00' + data.encode("utf-8") + b'\xff'
-        self.push(Write(sock, payload))
+        self.fire(Write(sock, payload))
 
     @handler("value_changed", target=WebSocketEvent._target)
     def _on_value_changed(self, value):
         sock, message = value.event.args
         result, data = value.result, value.value
         if result and isinstance(data, basestring):
-                self.push(Write(sock, data),
+                self.fire(Write(sock, data),
                         target=WebSocketEvent._target)
 
     @handler("read", filter=True)
             self._buffers[sock] += data
             messages = self._parse_messages(sock)
             for message in messages:
-                value = self.push(Message(sock, message))
+                value = self.fire(Message(sock, message))
                 value.onSet = "value_changed", WebSocketEvent._target
             return True
 

File circuits/web/dispatchers/xmlrpc.py

     def _on_value_changed(self, value):
         response = value.response
         response.body = self._response(value.value)
-        self.push(Response(response), target=self.channel)
+        self.fire(Response(response), target=self.channel)
         value.handled = True
 
     @handler("request", filter=True, priority=0.1)
             else:
                 t, c = self.target, method
 
-            value = self.push(RPC(*params), c, t)
+            value = self.fire(RPC(*params), c, t)
             value.response = response
             value.onSet = ("value_changed", self)
         except Exception as e:

File circuits/web/http.py

                 if response.chunked:
                     buf = [hex(len(data))[2:], b"\r\n", data, b"\r\n"]
                     data = b"".join(buf)
-                self.push(Write(response.request.sock, data))
+                self.fire(Write(response.request.sock, data))
             if response.body and not response.done:
                 try:
                     data = next(response.body)
                 except StopIteration:
                     data = None
-                self.push(Stream(response, data))
+                self.fire(Stream(response, data))
         else:
             if response.body:
                 response.body.close()
             if response.chunked:
-                self.push(Write(response.request.sock, b"0\r\n\r\n"))
+                self.fire(Write(response.request.sock, b"0\r\n\r\n"))
             if response.close:
-                self.push(Close(response.request.sock))
+                self.fire(Close(response.request.sock))
             response.done = True
 
     @handler("response")
     def _on_response(self, response):
-        self.push(
+        self.fire(
                 Write(response.request.sock,
                     str(response).encode(HTTP_ENCODING)))
 
                 data = next(response.body)
             except StopIteration:
                 data = None
-            self.push(Stream(response, data))
+            self.fire(Stream(response, data))
         else:
             if isinstance(response.body, bytes):
                 body = response.body
                 if response.chunked:
                     buf = [hex(len(body))[2:].encode(), b"\r\n", body, b"\r\n"]
                     body = b"".join(buf)
-                self.push(Write(response.request.sock, body))
+                self.fire(Write(response.request.sock, body))
 
                 if response.chunked:
-                    self.push(Write(response.request.sock, b"0\r\n\r\n"))
+                    self.fire(Write(response.request.sock, b"0\r\n\r\n"))
 
             if not response.stream:
                 if response.close:
-                    self.push(Close(response.request.sock))
+                    self.fire(Close(response.request.sock))
                 response.done = True
 
     @handler("disconnect")
             self._clients[sock] = request, response
 
             if frag:
-                return self.push(HTTPError(request, response, 400))
+                return self.fire(HTTPError(request, response, 400))
 
             if params:
                 path = "%s;%s" % (path, params)
             # the client only understands 1.0. RFC 2616 10.5.6 says we should
             # only return 505 if the _major_ version is different.
             if not request.protocol[0] == request.server_protocol[0]:
-                return self.push(HTTPError(request, response, 505))
+                return self.fire(HTTPError(request, response, 505))
 
             rp = request.protocol
             sp = request.server_protocol
             request.body.write(data[(end_of_headers + 4):])
 
             if headers.get("Expect", "") == "100-continue":
-                return self.push(Response(wrappers.Response(request, 100),
+                return self.fire(Response(wrappers.Response(request, 100),
                     encoding=self._encoding))
 
             contentLength = int(headers.get("Content-Length", "0"))
         else:
             req = Request(request, response)
 
-        self.push(req)
+        self.fire(req)
 
     @handler("httperror")
     def _on_httperror(self, event, request, response, code, **kwargs):
         """
 
         response.body = str(event)
-        self.push(Response(response))
+        self.fire(Response(response))
 
     @handler("value_changed")
     def _on_value_changed(self, value):
         request, response = value.event.args[:2]
         if value.result and not value.errors:
             response.body = value.value
-            self.push(Response(response))
+            self.fire(Response(response))
         else:
             # This possibly never occurs.
-            self.push(HTTPError(request, response, error=value.value))
+            self.fire(HTTPError(request, response, error=value.value))
 
     @handler("request_success", "request_filtered")
     def _on_request_success_or_filtered(self, evt, handler, retval):
         if not request.handled and retval is not None:
             request.handled = True
             if isinstance(retval, HTTPError):
-                self.push(retval)
+                self.fire(retval)
             elif isinstance(retval, wrappers.Response):
-                self.push(Response(retval))
+                self.fire(Response(retval))
             elif isinstance(retval, Value):
                 if retval.result and not retval.errors:
                     response.body = retval.value
-                    self.push(Response(response))
+                    self.fire(Response(response))
                 elif retval.errors:
                     error = retval.value
                     etype, evalue, traceback = error
                     if isinstance(evalue, RedirectException):
-                        self.push(RedirectError(request, response,
+                        self.fire(RedirectError(request, response,
                             evalue.urls, evalue.status))
                     elif isinstance(evalue, HTTPException):
                         if evalue.traceback:
-                            self.push(HTTPError(request, response, evalue.code,
+                            self.fire(HTTPError(request, response, evalue.code,
                                 description=evalue.description, error=error))
                         else:
-                            self.push(HTTPError(request, response, evalue.code,
+                            self.fire(HTTPError(request, response, evalue.code,
                                 description=evalue.description))
                     else:
-                        self.push(HTTPError(request, response, error=error))
+                        self.fire(HTTPError(request, response, error=error))
                 else:
                     if retval.manager is None:
                         retval.manager = self
                     retval.onSet = "value_changed", self
             elif type(retval) is not bool:
                 response.body = retval
-                self.push(Response(response))
+                self.fire(Response(response))
 
     @handler("request_failure", "response_failure")
     def _on_request_or_response_failure(self, evt, handler, error):
         etype, evalue, traceback = error
 
         if isinstance(evalue, RedirectException):
-            self.push(RedirectError(request, response,
+            self.fire(RedirectError(request, response,
                 evalue.urls, evalue.status))
         elif isinstance(evalue, HTTPException):
             if evalue.traceback:
-                self.push(HTTPError(request, response, evalue.code,
+                self.fire(HTTPError(request, response, evalue.code,
                     description=evalue.description, error=error))
             else:
-                self.push(HTTPError(request, response, evalue.code,
+                self.fire(HTTPError(request, response, evalue.code,
                     description=evalue.description))
         else:
-            self.push(HTTPError(request, response, error=error))
+            self.fire(HTTPError(request, response, error=error))
 
     @handler("request_completed")
     def _on_request_completed(self, evt, handler, retval):
 
         if not request.handled or handler is None or \
                 (evt.value.value is None and not evt.future):
-            self.push(NotFound(request, response))
+            self.fire(NotFound(request, response))

File circuits/web/servers.py

 
     @handler("read", target="stdin")
     def read(self, data):
-        self.push(Read(FakeSock(), data), "read", self.channel)
+        self.fire(Read(FakeSock(), data), "read", self.channel)
 
     @handler("write")
     def write(self, sock, data):
-        self.push(Write(data), "write", "stdout")
+        self.fire(Write(data), "write", "stdout")
 

File circuits/web/wsgi.py

 
     def __call__(self, environ, start_response, exc_info=None):
         self.request, self.response = self.getRequestResponse(environ)
-        self.push(Request(self.request, self.response))
+        self.fire(Request(self.request, self.response))
 
         self._finished = False
         while not self._finished:

File examples/web/terminal/terminal.py

     @handler("disconnect", target="server")
     def disconnect(self, sock):
         if sock == self._request.sock:
-            self.push(Kill(), target=self)
+            self.fire(Kill(), target=self)
 
     @handler("response", target="http", priority=-1)
     def response(self, response):
 
     def input(self, data):
         if self._stdin is not None:
-            self.push(Write(data), target=self._stdin)
+            self.fire(Write(data), target=self._stdin)
 
     def _on_stdout_eof(self):
         if self._buffer is not None:
             self._buffer.flush()
             data = self._buffer.getvalue()
-            self.push(Stream(self._response, data), target="http")
-        self.push(Stream(self._response, None), target="http")
-        self.push(Kill())
+            self.fire(Stream(self._response, data), target="http")
+        self.fire(Stream(self._response, None), target="http")
+        self.fire(Kill())
 
     def _on_stdout_read(self, data):
         if self._state == BUFFERING:
                 self._buffer.flush()
                 data = self._buffer.getvalue()
                 self._buffer = None
-                self.push(Stream(self._response, data), target="http")
+                self.fire(Stream(self._response, data), target="http")
             else:
-                self.push(Stream(self._response, data), target="http")
+                self.fire(Stream(self._response, data), target="http")
 
 class Root(Controller):
 

File scripts/circuits.bench

     concurrency = 1
 
     def received(self, message=""):
-        self.push(Hello("hello"))
+        self.fire(Hello("hello"))
 
 class Receiver(Base):
 
     def helo(self, address, port):
-        self.push(Hello("hello"))
+        self.fire(Hello("hello"))
 
     def hello(self, message=""):
-        self.push(Received(message))
+        self.fire(Received(message))
 
 class SpeedTest(Base):
 
     def hello(self, message):
-        self.push(Hello(message))
+        self.fire(Hello(message))
 
 class LatencyTest(Base):
 
     def received(self, message=""):
         print("Latency: %0.3f us" % ((time.time() - self.t) * 1e6))
         time.sleep(1)
-        self.push(Hello("hello"))
+        self.fire(Hello("hello"))
 
     def hello(self, message=""):
         self.t = time.time()
-        self.push(Received(message))
+        self.fire(Received(message))
     
 class State(Base):
 
     done = False
 
     def stop(self):
-        self.push(Term())
+        self.fire(Term())
 
     def term(self):
         self.done = True

File tests/app/test_env.py

 def test_create(env, path):
     from circuits.app.env import Create
 
-    env.push(Create())
+    env.fire(Create())
     assert pytest.wait_event(env, "create_success")
 
     files = ("conf/test.ini", "README", "VERSION")
 def test_load(env, path):
     from circuits.app.env import Create, Load
 
-    env.push(Create())
+    env.fire(Create())
 
     assert pytest.wait_event(env, "create_success")
 
     for filename in files:
         assert path.join(filename).check(exists=True, file=True)
 
-    env.push(Load())
+    env.fire(Load())
 
     assert pytest.wait_event(env, "load_success")
 
 def test_load_verify(env, path):
     from circuits.app.env import Create, Load
 
-    env.push(Create())
+    env.fire(Create())
 
     assert pytest.wait_event(env, "create_success")
 
     for filename in files:
         assert path.join(filename).check(exists=True, file=True)
 
-    env.push(Load(verify=True))
+    env.fire(Load(verify=True))
 
     assert pytest.wait_event(env, "load_success")
 
     from circuits.app.env import Create, Load
     from circuits.app.env import EnvironmentError, ERRORS
 
-    env.push(Create())
+    env.fire(Create())
 
     assert pytest.wait_event(env, "create_success")
 
 
     path.join("VERSION").write("")
 
-    v = env.push(Load(verify=True))
+    v = env.fire(Load(verify=True))
 
     assert pytest.wait_event(env, "verify_failure")
 
     from circuits.app.env import Create, Load
     from circuits.app.env import EnvironmentError, ERRORS
 
-    env.push(Create())
+    env.fire(Create())
 
     assert pytest.wait_event(env, "create_success")
 
 
     env.version = 100
 
-    v = env.push(Load(verify=True))
+    v = env.fire(Load(verify=True))
 
     assert pytest.wait_event(env, "verify_failure")
 

File tests/app/test_logger.py

 class App(Component):
 
     def test(self, level="debug"):
-        self.push(Log(level, "Hello World!"))
+        self.fire(Log(level, "Hello World!"))
 
 def test(tmpdir):
     filepath = tmpdir.ensure("test.log")
     f = open(filename, "r+")
 
     def test(f, level="debug"):
-        app.push(Test(level))
+        app.fire(Test(level))
         while app:
             app.flush()
         now = strftime("%H:%M:%S")

File tests/core/test_all_channels.py

     while m:
         m.flush()
 
-    m.push(Event(), "*")
+    m.fire(Event(), "*")
     m.flush()
 
     assert not a.flag

File tests/core/test_bridge.py

     pid = os.getpid()
     e = Hello()
     assert e.future == False
-    x = app.push(e)
+    x = app.fire(e)
 
     assert pytest.wait_for(e, "future", True)
     assert e.future == True

File tests/core/test_component_repr.py

     app.flush()
     assert repr(app) == "<App/* %s (queued=0, channels=2, handlers=2) [S]>" % id
 
-    app.push(Event(), "test")
+    app.fire(Event(), "test")
     assert repr(app) == "<App/* %s (queued=1, channels=2, handlers=2) [S]>" % id
 
     app.flush()

File tests/core/test_debugger.py

     assert debugger.events
 
     e = Event()
-    app.push(e)
+    app.fire(e)
     app.flush()
 
     stderr.seek(0)
     assert not debugger.events
 
     e = Event()
-    app.push(e)
+    app.fire(e)
 
     stderr.seek(0)
     s = stderr.read().strip()
     assert debugger.events
 
     e = Event()
-    app.push(e)
+    app.fire(e)
     app.flush()
 
     stderr.seek(0)
     assert not debugger.events
 
     e = Event()
-    app.push(e)
+    app.fire(e)
 
     stderr.seek(0)
     s = stderr.read().strip()
     assert debugger.events
 
     e = Event()
-    app.push(e)
+    app.fire(e)
     app.flush()
 
     stderr.seek(0)
     assert not debugger.events
 
     e = Event()
-    app.push(e)
+    app.fire(e)
 
     stderr.seek(0)
     s = stderr.read().strip()
     assert debugger.errors
 
     e = Test(raiseException=True)
-    app.push(e)
+    app.fire(e)
     app.flush()
 
     stderr.seek(0)
     assert not debugger.errors
 
     e = Test(raiseException=True)
-    app.push(e)
+    app.fire(e)
     app.flush()
 
     stderr.seek(0)
     debugger.IgnoreEvents.extend([Test])
 
     e = Event()
-    app.push(e)
+    app.fire(e)
     app.flush()
 
     stderr.seek(0)
     stderr.truncate()
 
     e = Test()
-    app.push(e)
+    app.fire(e)
     app.flush()
 
     stderr.seek(0)
     debugger.IgnoreChannels.extend([("*", "test")])
 
     e = Event()
-    app.push(e)
+    app.fire(e)
     app.flush()
 
     stderr.seek(0)
     stderr.truncate()
 
     e = Test()
-    app.push(e)
+    app.fire(e)
     app.flush()
 
     stderr.seek(0)
         app.flush()
 
     e = Event()
-    app.push(e)
+    app.fire(e)
     app.flush()
 
     assert logger.msg == repr(e)
         app.flush()
 
     e = Test(raiseException=True)
-    app.push(e)
+    app.fire(e)
     app.flush()
     app.flush()
     assert logger.msg.startswith("ERROR <listener on ('test',) {target='*', priority=0.0}> (<class 'Exception'>):") \

File tests/core/test_dynamic_handlers.py

     app = App()
 
     e = Test()
-    app.push(e)
+    app.fire(e)
     app.flush()
 
     assert app._event == e
     app = App()
 
     e = Test()
-    app.push(e, target="foo")
+    app.fire(e, target="foo")
     app.flush()
 
     assert app._event == e

File tests/core/test_errors.py

     while app:
         app.flush()
 
-    app.push(Test())
+    app.fire(Test())
     while app:
         app.flush()
 

File tests/core/test_event.py

     s = repr(e)
     assert s == "<Test[] [] {}>"
 
-    app.push(e)
+    app.fire(e)
 
     s = repr(e)
     assert s == "<Test[*:test] [] {}>"

File tests/core/test_event_serialization.py

     while app: app.flush()
 
     e = Test()
-    app.push(e)
+    app.fire(e)
     app.flush()
 
     s = dumps(e, -1)

File tests/core/test_feedback.py

         app.flush()
 
     e = Test()
-    x = app.push(e)
+    x = app.fire(e)
 
     app.flush()
 
         app.flush()
 
     e = Test(error=True)
-    x = app.push(e)
+    x = app.fire(e)
 
     app.flush()
 
         app.flush()
 
     e = Test(filter=True)
-    x = app.push(e)
+    x = app.fire(e)
 
     app.flush()
 

File tests/core/test_filters.py

 def test():
     app = App()
     while app: app.flush()
-    x = app.push(Test())
+    x = app.fire(Test())
     app.flush()
     assert x.value == "Hello World!"

File tests/core/test_future.py

 
     @future()
     def test(self):
-        return self.push(Hello())
+        return self.fire(Hello())
 
     @future()
     def error(self):
     @handler("test")
     @future()
     def _on_test(self):
-        return self.push(Hello())
+        return self.fire(Hello())
 
     @handler("error")
     @future()
     while app: app.flush()
     e = Test()
     assert e.future == False
-    x = app.push(e)
+    x = app.fire(e)
     while not x.result:
         app.flush()
     assert e.future == True
     while app: app.flush()
     e = Error()
     assert e.future == False
-    x = app.push(e)
+    x = app.fire(e)
     while not x.errors:
         app.flush()
     assert e.future == True
     while app: app.flush()
     e = Test()
     assert e.future == False
-    x = app.push(e)
+    x = app.fire(e)
     while not x.result:
         app.flush()
     assert e.future == True
     while app: app.flush()
     e = Error()
     assert e.future == False
-    x = app.push(e)
+    x = app.fire(e)
     while not x.errors:
         app.flush()
     assert e.future == True

File tests/core/test_generator_value.py

     app = App()
     while app: app.flush()
 
-    v = app.push(Test())
+    v = app.fire(Test())
     app.flush()
 
     g = v.value
     app = App()
     while app: app.flush()
 
-    v = app.push(Hello())
+    v = app.fire(Hello())
     app.flush()
 
     g = v.value

File tests/core/test_greenlet.py

         return x.value
 
     def bar(self):
-        self.push(BarDone())
+        self.fire(BarDone())
         return "Foobar!"
 
     def bar2(self):
-        self.push(BarDone())
+        self.fire(BarDone())
         return
 
 

File tests/core/test_inheritence.py

     app = App1()
     app.start()
 
-    x = app.push(Test())
+    x = app.fire(Test())
     assert pytest.wait_for(x, "result")
     v = x.value
     assert v == ["Hello World!", "Foobar"]
     app = App2()
     app.start()
 
-    x = app.push(Test())
+    x = app.fire(Test())
     assert pytest.wait_for(x, "result")
     v = x.value
     assert v == "Foobar"

File tests/core/test_ipc.py

 
     assert pytest.wait_for(app._bridge, "ready")
 
-    x = m.push(Hello())
+    x = m.fire(Hello())
 
     assert pytest.wait_for(x, "result")
     s = str(x)

File tests/core/test_loader.py

 
     loader.load("app")
 
-    x = m.push(Test())
+    x = m.fire(Test())
 
     assert pytest.wait_for(x, "result")
 

File tests/core/test_manager_repr.py

     m.flush()
     assert repr(m) == "<Manager %s (queued=0, channels=2, handlers=2) [S]>" % id
 
-    m.push(Event(), "test")
+    m.fire(Event(), "test")
     assert repr(m) == "<Manager %s (queued=1, channels=2, handlers=2) [S]>" % id
 
     m.flush()

File tests/core/test_pools.py

     p = Pool()
     p.start()
 
-    x = p.push(Task(f))
+    x = p.fire(Task(f))
 
     assert pytest.wait_for(x, "result")
 

File tests/core/test_priority.py

 while m: m.flush()
 
 def test():
-    v = m.push(Test())
+    v = m.fire(Test())
     while m: m.flush()
     x = list(v)
     assert x == [3, 2, 0]

File tests/core/test_value.py

         return "Hello World!"
 
     def test(self):
-        return self.push(Hello())
+        return self.fire(Hello())
 
     def error(self):
         raise Exception("Error!")
 
     @handler("values", priority=0.0)
     def _value3(self):
-        return self.push(Hello())
+        return self.fire(Hello())
 
 
 m = Manager()
 while m: m.flush()
 
 def test_value():
-    x = m.push(Hello())
+    x = m.fire(Hello())
     while m: m.flush()
     assert "Hello World!" in x
     assert x.value == "Hello World!"
 
 def test_nested_value():
-    x = m.push(Test())
+    x = m.fire(Test())
     while m: m.flush()
     assert x.value == "Hello World!"
     assert str(x) == "Hello World!"
 
 def test_error_value():
-    x = m.push(Error())
+    x = m.fire(Error())
     while m: m.flush()
     etype, evalue, etraceback = x
     assert etype is Exception
     assert isinstance(etraceback, list)
 
 def test_multiple_values():
-    v = m.push(Values())
+    v = m.fire(Values())
     while m: m.flush()
     assert isinstance(v.value, list)
     x = list(v)

File tests/core/test_value_serialization.py

     app = App()
     while app: app.flush()
 
-    v = app.push(Test())
+    v = app.fire(Test())
     while app: app.flush()
 
     s = dumps(v, -1)

File tests/core/test_workers.py

 def test():
     w = Worker()
 
-    x = w.push(Task(f))
+    x = w.fire(Task(f))
 
     while not x.result: pass
 

File tests/io/test_io.py

 
     app = App(filename, "w")
     app.start()
-    app.push(Write(b"Hello World!"))
+    app.fire(Write(b"Hello World!"))
     sleep(1)
     app.stop()
 

File tests/net/protocols/test_irc.py

 def test_PASS(app):
     app.reset()
 
-    app.push(PASS("secret"))
+    app.fire(PASS("secret"))
     while app:
         app.flush()
 
 def test_USER(app):
     app.reset()
 
-    app.push(USER("foo", "localhost", "localhost", "Test Client"))
+    app.fire(USER("foo", "localhost", "localhost", "Test Client"))
     while app:
         app.flush()
 
 def test_NICK(app):
     app.reset()
 
-    app.push(NICK("test"))
+    app.fire(NICK("test"))
     while app:
         app.flush()
 
 def test_PING(app):
     app.reset()
 
-    app.push(PING("localhost"))
+    app.fire(PING("localhost"))
     while app:
         app.flush()
 
 def test_PONG(app):
     app.reset()
 
-    app.push(PONG("localhost"))
+    app.fire(PONG("localhost"))
     while app:
         app.flush()
 
 def test_QUIT(app):
     app.reset()
 
-    app.push(QUIT())
+    app.fire(QUIT())
     while app:
         app.flush()
 
 
     app.reset()
 
-    app.push(QUIT("Test"))
+    app.fire(QUIT("Test"))
     while app:
         app.flush()
 
 def test_JOIN(app):
     app.reset()
 
-    app.push(JOIN("#test"))
+    app.fire(JOIN("#test"))
     while app:
         app.flush()
 
 
     app.reset()
 
-    app.push(JOIN("#test", "secret"))
+    app.fire(JOIN("#test", "secret"))
     while app:
         app.flush()
 
 def test_PART(app):
     app.reset()
 
-    app.push(PART("#test"))
+    app.fire(PART("#test"))
     while app:
         app.flush()
 
 
     app.reset()
 
-    app.push(PART("#test", "Test"))
+    app.fire(PART("#test", "Test"))
     while app:
<