def __init__(self, items=()):
        EventBus.__init__(self)
        self.deq = collections.deque()
        self.lock = threading.Lock()
        self.event = threading.Event()

        self.onfini( self._onQueFini )

    def __init__(self, queen, **config):
        # NOTE: queen must *always* be a telepath proxy

        EventBus.__init__(self)

        self.iden = guid()

        self.slots = {}
        self.slocs = {}

        self.queen = queen
        self.config = config

        # FIXME maybe put our hostname etc in config?

        self.queen.on('tele:sock:init', self._onTeleSockInit )
        self.queen.on('hive:tell:%s' % self.iden, self._onHiveTell)

        self.localurl = 'local://%s/syn.queen' % self.iden

        # each worker has a local:// daemon
        self.dmon = s_daemon.Daemon()
        self.dmon.listen(self.localurl)

        self.dmon.share('syn.queen',queen)

        self.on('hive:slot:run', self._onHiveSlotRun)
        self.on('hive:slot:fini', self._onHiveSlotFini)

        self._initQueenProxy()

    def __init__(self, core):

        EventBus.__init__(self)
        self.core = core

        self.keys = c_cache.Cache()
        self.keys.setOnMiss( self._getRsaKey )

        self.pubs = c_cache.Cache()
        self.pubs.setOnMiss( self._getPubKey )

        self.certs = c_cache.Cache()
        self.certs.setOnMiss( self._getTokenCert )

        self.tokens = c_cache.Cache()
        self.tokens.setOnMiss( self._getTokenTufo )

        core.onfini( self.keys.fini )
        core.onfini( self.pubs.fini )
        core.onfini( self.certs.fini )
        core.onfini( self.tokens.fini )

        core.addTufoForm('syn:token', ptype='str', doc='synapse identity token (user/host)')

        core.addTufoProp('syn:token', 'user', doc='humon readable user name for this token')
        core.addTufoProp('syn:token', 'host', doc='humon readable host name for this token')

        core.addTufoProp('syn:token', 'blob', doc='Base64 encoded token blob')
        core.addTufoProp('syn:token', 'cert', doc='Base64 encoded certificate blob')
        core.addTufoProp('syn:token', 'rsakey', doc='base64( der( rsa.private ) )')

    def __init__(self):
        EventBus.__init__(self)
        self.threads = {}

        self.on('thread:init', self._initThread)
        self.on('thread:fini', self._finiThread)
        self.onfini(self._finiThreadBoss)

    def __init__(self, cura, sess):
        EventBus.__init__(self)

        self.sid = sess[0]
        self.cura = cura
        self.sess = sess

        self.local = {}      # runtime only props

    def __init__(self):
        EventBus.__init__(self)
        self.tagsbyname = {}
        self.coresbyname = {}

        self.coresbytag = collections.defaultdict(list)

        self.onfini( self._onMetaFini )

    def __init__(self):
        EventBus.__init__(self)

        self.root = None
        self.lock = threading.Lock()
        self.wake = threading.Event()

        self.thr = self._runSchedMain()
        self.onfini( self._onSchedFini )

    def __init__(self, relay):
        EventBus.__init__(self)
        self.relay = relay

        self.boss = s_threads.ThreadBoss()
        self.onfini(self.boss.fini)

        # we get the sock first to fill in info
        self.on('link:sock:init', self._onLinkSockInit)

    def __init__(self, maxsize=10000, onmiss=None):
        EventBus.__init__(self)

        self.cache = {}
        self.onmiss = onmiss
        self.maxsize = maxsize
        self.cachelock = threading.Lock()

        self.fifo = collections.deque()

    def __init__(self, sock, **info):
        EventBus.__init__(self)
        self.sock = sock
        self.unpk = msgpack.Unpacker(use_list=0,encoding='utf8')
        self.ident = s_common.guid()
        self.xforms = []        # list of SockXform instances
        self.crypto = None
        self.sockinfo = info

        self.onfini(self._finiSocket)

    def __init__(self, core=None, maxtime=onehour):
        EventBus.__init__(self)

        self.core = core

        self.cache = s_cache.Cache(maxtime=maxtime)
        self.cache.setOnMiss( self._getSessByIden )
        self.cache.on('cache:pop', self._onSessCachePop )

        self.onfini( self.cache.fini )

    def __init__(self):
        #cmd.Cmd.__init__(self)
        EventBus.__init__(self)

        self.cmdfuncs = {}
        self.cmdprompt = 'cli> '

        self.addCmdMeths(self)
        self.addCmdFunc(cmd_quit, name='quit')
        self.addCmdFunc(cmd_help, name='help')

    def __init__(self, link):
        EventBus.__init__(self)

        self.link = link
        self.relay = s_link.initLinkRelay(link)
        self.client = self._init_client()

        self._tele_with = {}    # tid:client for with blocks

        # objname is path minus leading "/"
        self.objname = link[1].get('path')[1:]

    def __init__(self, statefd=None):
        self.authinfo = {}
        self.authrules = collections.defaultdict(dict)

        EventBus.__init__(self)
        StateMachine.__init__(self, statefd=statefd)

        if self.getAuthInfo('defauth') == None:
            self.setAuthInfo('defauth', False)

        self._loadAuthRules()

    def __init__(self, func, *args, **kwargs):
        EventBus.__init__(self)

        threading.Thread.__init__(self)
        self.setDaemon(True)

        self.iden = guid()
        self.task = (func,args,kwargs)

        self.cancels = []

        self.onfini( self._onThrFini )

    def __init__(self):
        EventBus.__init__(self)

        self.coreok = {}
        self.cordefs = {}
        self.tagsbyname = {}
        self.coresbyname = {}

        self.sched = s_sched.Sched()
        self.coresbytag = collections.defaultdict(list)

        self.onfini( self._onMetaFini )

    def __init__(self, fd, **opts):
        EventBus.__init__(self)

        fd.seek(0, os.SEEK_END)

        self.fd = fd
        self.size = fd.tell()
        self.fdoff = self.size
        self.fileno = fd.fileno()

        self.lock = threading.Lock()

        self.onfini( self._onAtomFini )

    def __init__(self, sock, **info):
        EventBus.__init__(self)

        self.sock = sock
        self.plex = None
        self.unpk = msgpack.Unpacker(use_list=0,encoding='utf8')
        self.iden = s_common.guid()
        self.xforms = []        # list of SockXform instances
        self.info = info

        # used by Plex() tx
        self.txbuf = None
        self.txque = collections.deque()

        self.onfini(self._finiSocket)

    def __init__(self):
        EventBus.__init__(self)

        self.onfini( self._onBossFini )

        self.pool = None
        self.sched = s_sched.getGlobSched()

        self.joblock = threading.Lock()

        self._boss_jobs = {}
        self.joblocal = {}

        self.on('job:done', self._onJobDone )  # trigger job done
        self.on('job:fini', self._onJobFini )  # job is finished

    def __init__(self, **settings):
        EventBus.__init__(self)
        s_daemon.DmonConf.__init__(self)
        tornado.web.Application.__init__(self, **settings)

        self.loop = tornado.ioloop.IOLoop.current()
        self.serv = tornado.httpserver.HTTPServer(self)

        self.boss = s_async.Boss()

        # FIXME options
        self.boss.runBossPool(8, maxsize=128)

        self.iothr = self._runWappLoop()

        self.onfini( self._onWappFini )