Reactjs react redux saga rootTask.done从未解决

当我运行sagaMiddleware时

rootTask的（sagaMiddleware.run（rootSaga）返回）完成承诺从未得到解决，问题在哪里

todo.sagas.js

import { put } from 'redux-saga/effects';
import { takeEvery } from 'redux-saga';

function* addTodoHandler(action){
    yield put({type: 'addTodo', payload: action.payload})
}

const testWatcher = function* (){
    yield takeEvery('addTodoAsync', addTodoHandler);
}

export default {
    testWatcher
}

registerSagas.js

let rs = [];
rs.push(require('./todo/todo.sagas'));
let sagasMap = rs.reduce((o, m) => {
    for(var p in m['default']){
        o[p] = m['default'][p];
    }
    return o;
}, {});
let sagas = Object.keys(sagasMap).map(k => sagasMap[k]);
rootSaga = function*(){
    yield sagas.map(saga => saga());
}

服务器端渲染 根任务从未解决，一直挂起

export function RouteMatchHandler(data){
  return new Promise((resolve, reject) => {
    match(data, (error, redirectLocation, renderProps) => {
      if (error) {
        return resolve({
          code: 500,
          payload: error
        });
      } else if (redirectLocation) {
        let url = redirectLocation.pathname + redirectLocation.search;
        return resolve({
          code: 301,
          payload: url
        });
      } else if (renderProps) {
        let { query, params, components, history} = renderProps;
        let store = configureStore();
        let rootTask = store.runSaga(rootSaga);
        let html = null;
        wrap(execFetchDataEntryPoint)(components, { query, params, store, history })
          .then(() => {
            renderToString(
              <Provider store={store}>
                {<RouterContext {...renderProps} />}
              </Provider>
            )
            return store.dispatch(END);
          })
          .then(() => {
            return rootTask.done  // never been resolved, pending     continously!!!
          })
          .then(() => {
            html = renderToString(
              <Provider store={store}>
                {<RouterContext {...renderProps} />}
              </Provider>
            )
            return resolve({
              code: 200,
              payload: {html, state: store.getState()}
            });
          })
      } else {
        return resolve({
            code: 301,
            payload: 'NOT FOUND'
          });
      }
    })
  });
}

//helpers
function* execFetchDataEntryPoint(components, metadata){
  if(!components || !components.length){
    return;
  }
  let component = components[0].WrappedComponent ? components[0].WrappedComponent : components[0];
  if(component.fetchData){
    yield component.fetchData(metadata);
  }
  return yield getFetchDataEntryPoint(components.slice(1), metadata);
}

导出函数RouteMatchHandler（数据）{
返回新承诺（（解决、拒绝）=>{
匹配（数据，（错误、重定向位置、渲染器操作）=>{
如果（错误）{
返回解析({
代码：500，
有效载荷：错误
});
}else if（重定向位置）{
让url=redirectLocation.pathname+redirectLocation.search；
返回解析({
代码：301，
有效负载：url
});
}else if（渲染器操作）{
让{query，params，components，history}=renderProps；
let store=configureStore（）；
让rootTask=store.runSaga（rootSaga）；
设html=null；
wrap（execFetchDataEntryPoint）（组件，{query，params，store，history}）
.然后（（）=>{
渲染字符串(
{}
)
退货、发货（结束）；
})
.然后（（）=>{
return rootTask.done//从未解析，持续挂起！！！
})
.然后（（）=>{
html=renderToString(
{}
)
返回解析({
代码:200,，
有效负载：{html，状态：store.getState（）}
});
})
}否则{
返回解析({
代码：301，
有效负载：“未找到”
});
}
})
});
}
//助手
函数*execFetchDataEntryPoint（组件、元数据）{
如果（！components | |！components.length）{
返回；
}
让组件=组件[0]。WrappedComponent？组件[0]。WrappedComponent:组件[0]；
if（component.fetchData）{
获取数据（元数据）；
}
返回yield getFetchDataEntryPoint（components.slice（1），元数据）；
}