docs: def make_crossroad_router(source, drain=False):
      ''' legacy crossroad implementation. deprecated
      '''
      sink_observer = None
  
      def on_sink_subscribe(observer):
          nonlocal sink_observer
          sink_observer = observer
  
          def dispose():
              nonlocal sink_observer
              sink_observer = None
  
          return dispose
  
      def route_crossroad(request):
          def on_response_subscribe(observer):
              def on_next_source(i):
                  if type(i) is cyclotron.Drain:
                      observer.on_completed()
                  else:
                      observer.on_next(i)
  
              source_disposable = source.subscribe(
                  on_next=on_next_source,
                  on_error=lambda e: observer.on_error(e),
                  on_completed=lambda: observer.on_completed()
              )
  
              def on_next_request(i):
                  if sink_observer is not None:
                      sink_observer.on_next(i)
  
              def on_request_completed():
                  if sink_observer is not None:
                      if drain is True:
                          sink_observer.on_next(cyclotron.Drain())
                      else:
                          sink_observer.on_completed()
  
              request_disposable = request.subscribe(
                  on_next=on_next_request,
                  on_error=observer.on_error,
                  on_completed=on_request_completed
              )
  
              def dispose():
                  source_disposable.dispose()
                  request_disposable.dispose()
  
              return dispose
  
          return Observable.create(on_response_subscribe)
  
      return Observable.create(on_sink_subscribe), route_crossroad