TypeScript task.makeTask_函数代码示例

export function submitForm<R extends Readable>(mutter: W.Middleware, form: R): T.Task<W.HttpContext> {
  return T.makeTask_(cb => {
    (form as any).getLength((err: Error | null, len: number) => {
      if (err) return cb(err);

      const app = mutter(simpleApp);
      const request = new PassThrough();
      (request as any).complete = false;
      form.once('end', () => {
        (request as any).complete = true;
      });

      form.pipe(request);
      (request as any).headers = {
        'content-type': 'multipart/form-data; boundary=' + (form as any).getBoundary(),
        'content-length': len
      };

      const ctx: W.HttpContext = W.createHttpContext(request as any);

      T.runTask(app(ctx, T.pure), err => {
        if (err) return cb(err);

        cb(null, ctx);
      });
    });
  });
}

 return T.toPromise(withApp(app, handler =>
   T.makeTask_(cb => {
     request(handler)
       .get('/')
       .expect(304)
       .end(cb);
   })

function connect(uri: string): T.Task<Redis.Redis> {
  return T.makeTask_(cb => {
    const redis = new Redis(uri);
    redis.on('ready', () => {
      cb(null, redis);
    });
  });
}

function quit(redis: Redis.Redis): T.Task<void> {
  return T.makeTask_(cb => {
    redis.quit(function (err, ok) {
      if (err) return cb(err);
      if (ok === 'OK') cb(null);
      cb(new Error('quit return ' + ok));
    });
  });
}

function closeServer(server: Server | HServer | null): T.Task<void> {
  return T.makeTask_(cb => {
    if (server == null) {
      return process.nextTick(() => cb(null, void 0));
    }
    server.close(() => {
      cb(null, void 0);
    });
  });
}

 return withApp(partialApp, handler => {
   return T.makeTask_(cb => {
     request(handler)
       .get('/')
       .expect(out)
       .expect((response: request.Response) => {
         assert.equal(response.header['content-length'], out.length.toString());
         assert.equal(response.header['content-ranges'], range);
       })
       .end(cb);
   });
 });

function parseMultipartBody(ctx: HttpContext, opts?: MutterOptions): T.Task<[Params, Files]> {
  return T.makeTask_(cb => {
    const options: MutterOptions = opts || {};
    const req = ctx.request;
    const fileFilter = options.fileFilter || defaultFileFilter;
    const limits = options.limits;
    const storage = options.getStorage ? options.getStorage(ctx) : defaultGetStorage(ctx);

    const params = Object.create(null);
    const files = Object.create(null);

    const busboy = new Busboy({ limits, headers: req.headers, preservePath: options.preservePath });
    const _stream = getContentStream(req, req.headers);
    const stream = isJust(_stream) ? _stream.value : req;
    const pendingWrites = new Counter();
    let isDone = false;
    let readFinished = false;
    let errorOccured = false;
    let uploadedFiles: FileInfo[] = [];

    function done(err?: Error | null) {
      if (isDone) return;
      isDone = true;
      stream.unpipe(busboy);
      drainStream(stream);
      busboy.removeAllListeners();
      onFinished(req, () => {
        if (err) return cb(err);

        cb(null, [params, files]);
      });
    }

    function indicateDone() {
      if (readFinished && pendingWrites.isZero() && !errorOccured) done();
    }

    function abortWithError(uploadError: Error) {
      if (errorOccured) return;
      errorOccured = true;
      pendingWrites.onceZero(() => {
        T.runTask(T.forInPar_(uploadedFiles, file => storage.removeFile(file)), (err) => {
          /* istanbul ignore if */
          if (err) return done(err);
          done(uploadError);
        });
      });
    }

    function abortWithCode(code: keyof (typeof errorMessages), optionalField?: string) {
      abortWithError(makeError(code, optionalField));
    }

    busboy.on('field', (fieldname, value, fieldnameTruncated, valueTruncated) => {
      if (fieldnameTruncated) return abortWithCode('LIMIT_FIELD_KEY');
      if (valueTruncated) return abortWithCode('LIMIT_FIELD_VALUE', fieldname);

      // Work around bug in Busboy (https://github.com/mscdex/busboy/issues/6)
      if (limits && limits.hasOwnProperty('fieldNameSize')) {
        if (fieldname.length > (limits as any).fieldNameSize) return abortWithCode('LIMIT_FIELD_KEY');
      }

      appendField(params, fieldname, value);
    });

    busboy.on('file', (fieldname, filestream, originalname, encoding, mimeType) => {
      if (!fieldname) return filestream.resume();

      // Work around bug in Busboy (https://github.com/mscdex/busboy/issues/6)
      if (limits && limits.hasOwnProperty('fieldNameSize')) {
        if (fieldname.length > (limits as any).fieldNameSize) return abortWithCode('LIMIT_FIELD_KEY');
      }

      const file: FileUpload = {
        fieldname,
        originalname,
        encoding,
        mimeType
      };
      const placeholder = insertPlaceholder(files, file);

      T.runTask(fileFilter(ctx, file), (err, includeFile) => {
        if (err) {
          removePlaceholder(files, placeholder);
          return abortWithError(err);
        }

        if (!includeFile) {
          removePlaceholder(files, placeholder);
          return filestream.resume();
        }

        let aborting = false;
        pendingWrites.increment();

        filestream.on('error', (err) => {
          pendingWrites.decrement();
          abortWithError(err);
        });

//.........这里部分代码省略.........