def runRTMP(addr=('0.0.0.0', 1935)): # create and run a flash server instance
    server = rtmp.FlashServer()
    server.apps = dict({'record': Record, 'call': Call}) # only support call and record applications  
    server.root = 'www/flvs/'
    server.start(*addr)
    if _debug: print time.asctime(), 'Flash server starts', addr
    try: multitask.run()
    except KeyboardInterrupt: thread.interrupt_main()

	def run(self):
		while True:
			try:
				agent = rtmp.FlashServer()
				agent.start()
				multitask.run()
			except:
				sys.exit(0)		
			time.sleep(2)

 def startRtmp(self):
     try:
         agent = FlashServer()
         agent.root = self.root
         agent.start(self.host, self.port)
         log.info(( time.asctime() , 'Flash Server Starts - %s:%d' % (self.host, self.port)))
         multitask.run()
     except KeyboardInterrupt:
         pass
     log.info((time.asctime() ,'Flash Server Stops'))

def runRTMP(addr=("0.0.0.0", 1935)):  # create and run a flash server instance
    server = rtmp.FlashServer()
    server.apps = dict({"record": Record, "call": Call})  # only support call and record applications
    server.root = _www + _flvs
    server.start(*addr)
    if _debug:
        print time.asctime(), "Flash server starts", addr
    try:
        multitask.run()
    except KeyboardInterrupt:
        thread.interrupt_main()

def main():
    cput, cget = make_channel()

    def ping():
        for i in range(20):
            cput(i)
            yield ready

    def pong():
        while True:
            print (yield call(whee))

    def whee(answer):
        x = yield cget
        y = yield cget
        answer(x + y)

    spawn(pong())
    spawn(ping())
    run()

 def threadproc(arg):
     global sock1, pending, active
     def execute(s):
         if isinstance(s, p2p.ServerSocket):
             n = NetworkStub(Ks=crypto.generateRSA()[0], cert=None, model=model, view=control.view)
             s.start(net=n)
             node = model.addNode(s.net.node.guid, s)
             s.net.node.index = node.index # so that dht.Node has the index.
             active.append(s)
         else:
             if _debug: print s[0], s[1]
             result = yield s[0](**s[1])
             if not isinstance(result, list):
                 print result
             else:
                 if _debug: print result
                 values = map(lambda x: x[0], result)
                 print '\n'.join(values) if values else 'None'
     def waitonsock(sock):
         global pending
         try:
             while True: 
                 yield multitask.recvfrom(sock, 10)
                 for s in pending:
                     multitask.add(execute(s))
                 pending[:] = []
         except StopIteration:
             raise
         except:
             print 'waitonsock', sys.exc_info(), traceback.print_exc()
     multitask.add(waitonsock(sock1)) # this will trigger multitask out of wait loop
      
     if _debug: print 'starting multitask.run()'
     if _trace: sys.settrace(traceit)
     try: multitask.run()
     except KeyboardInterrupt: interrupt_main()
     except: 
         if _debug: print 'exception in multitask.run()'; traceback.print_exc()

              pass			
            p = None
          log.info('incoming call cancelled')	  
          break
    elif cmd == 'close':
      log.info('incoming call cancelled by %s', arg)
    elif cmd == 'send':
      log.info('paging-mode IM received %s', arg)	


if __name__ == '__main__':
  try:
    argv = sys.argv
    i, username, password, media = 1, None, None, None
    while i < len(argv):
      if argv[i] == '-u':
        if username:		
          multitask.add(register(username, password, media))
          username, password, media = None, None, None		
        username = argv[i+1]
      elif argv[i] == '-p':
        password = argv[i+1]
      elif argv[i] == '-m':
        media = argv[i+1]
      i += 2		
    multitask.add(register(username, password, media))
    multitask.run()
  except KeyboardInterrupt:
    pass

    

        for x in filter(lambda x: x.tag == 'filled', items):
            pass # TODO: more
        
#------------------------------------------------------------------------------
# TESTING        
#------------------------------------------------------------------------------

def _testInterpret():
    try:
        yield interpret('example/goodbye1.vxml') # initial example
        yield interpret('example/goodbye2.vxml') # initial example
        yield interpret('example/leaf.vxml')     # multi-document
        yield interpret('example/app.vxml')      # subdialog
    
    except StopIteration: pass
    except Exception, e:
        print 'exception', type(e), e, traceback.print_exc()
    yield

def _testClose(): yield multitask.sleep(2); exit()

if __name__ == '__main__':
    import doctest; doctest.testmod()    # first run doctest,
    for f in dir():      # then run all _test* functions
        if str(f).find('_test') == 0 and callable(eval(f)):
            multitask.add(globals()[f]())
    try: multitask.run()
    except KeyboardInterrupt: pass
    except select.error: print 'select error'; pass
    sys.exit()

def run():
    '''The run loop which runs the multitask's main loop. This can be terminated by KeyboardInterrupt.'''
    try: multitask.run()
    except KeyboardInterrupt: pass

def speed_test_1():
    t_start = time.time()
    multitask.add(coroutine_1())
    multitask.add(coroutine_2())
    multitask.run()
    print('sp1: {0} [ms]'.format((time.time() - t_start)*1000))