req = requestWithDefaults(url, options, (error: HttpError, response = resp, body?: any) => {
          // node.js assigns status string as body for status codes not having body data
          if (response && response.statusCode === 202) {
            diag.debug.assert(body === http.STATUS_CODES[202], body);
            body = undefined; // resolves promise to undefined below
          }

          // error processing
          if (!error && response && response.statusCode >= 400) {
            if (_.isError(body)) {
              // correct but practically impossible
              error = body;
            } else if (_.isString(body)) {
              // use plain-text as Error message
              error = new Error(body);
            } else if (_.isObjectLike(body)) {
              // body is object representation of server-side error or exception,
              // converting to true Error object here
              error = new Error(response.statusMessage);
              diag.debug.assert(() => !_.isArray(body),
                'kicks in for array responses as well, not sure if this is desirable');
              _.extend(error, body);
            } else {
              // handles numbers, booleans, etc. assigning as cause of failure
              error = new Error(response.statusMessage);
              if (!_.isUndefined(body)) {
                error.cause = body;
              }
            }
            // additional HttpError properties eventually set below
          }
          if (error) {
            // completes HttpError construction
            diag.debug.assertIsError(error, 'should operate true Error instances');
            error.requestUrl = url;
            if (response) {
              error.statusCode = response.statusCode;
              error.statusMessage = response.statusMessage;
              Object.defineProperty(error, 'rawResponse', {
                value: response,
                enumerable: false
              });
            }
            Object.defineProperty(error, 'rawRequest', {
              value: req,
              enumerable: false
            });
          }

          if (!response) {
            // network connectivity problem
            serverObj.serverInfos = null;
            diag.debug.assertIsError(error);
            if (promiseResponse) {
              rejectResponse(error); // will also rejectResult(error)
            } else {
              rejectResult(error); // promiseResponse not constructed yet
            }
          } else {
            // server information
            serverObj.serverInfos = {
              version: response.headers['x-relution-version'],
              description: response.headers['x-server']
            };
            if (response.statusCode === 503 ||
                response.statusCode === 500 && error.className === 'java.util.concurrent.TimeoutException') {
              // 503 (service unavailable) indicates the server is temporarily overloaded, and unable
              // handling the request. This happens when async delegation timed out on the Java side,
              // usually after about 2 minutes. In this case retry the request until we are done...
              diag.debug.info('server overloaded, retrying request.');
              // here promiseResponse must have been resolved already,
              // we chain anyways because of error propagation
              promiseResponse.thenResolve(ajax<T>(options)).done(resolveResult, rejectResult);
              return; // early exit as result is handled by done call above
            } else {
              // logon session processing
              let sessionUserUuid = response.headers['x-gofer-user'];
              if (sessionUserUuid) {
                serverObj.sessionUserUuid = sessionUserUuid;
              } else if (response.statusCode === 401) {
                // apparently our session is lost!
                serverObj.sessionUserUuid = null;
                diag.debug.assert(() => !!error);
                diag.debug.warn('server session is lost!', error);
                const credentials = serverObj.credentials;
                if (credentials) {
                  // recover by attempting login,
                  // here promiseResponse must have been resolved already,
                  // we chain anyways because of error propagation
                  serverObj.credentials = null;
                  promiseResponse.thenResolve(login(credentials, {
                    serverUrl: serverUrl
                  }).then(() => {
                    diag.debug.assert(() => !!serverObj.sessionUserUuid);
                    diag.debug.info('server session recovered.');
                    return ajax<T>(options);
                  })).done(resolveResult, rejectResult);
                  return; // early exit as result is handled by done call above
                }
              }
//.........这里部分代码省略.........

 }).catch(function (e) {
   assert(_.isError(e));
   done();
 });

  info (msg: string) {
    this.msg(LogType.INFO, msg)
  },
  debug (msg: string) {
    this.msg(LogType.DEBUG, msg)
  },
  msg (logType: LogType, msg: string | Error | Object | any[]) {
    if (logType.level < config.log.level) {
      return
    }

    let dateTime = config.log.time
      ? colors.gray(`[${getDateTime()}] `)
      : ''

    if (_.isError(msg)) {
      msg = msg.message
    } else if (_.isPlainObject(msg) || _.isArray(msg)) {
      msg = JSON.stringify(msg)
    }

    if (this.cb) {
      this.cb(msg, logType, dateTime)
    } else {
      let color = colors[logType.color]
      msg = dateTime + color(`[${logType.desc}]`) + ' ' + msg

      if (logType.level >= LogLevel.WARN) {
        console.error(msg)
      } else {
        console.log(msg)

export const error = (value: any): value is Error => isError(value)

 logError(level, message, err) {
   const errorMessage = _.isError(err)
     ? err.message
     : err
   this.log(level, `${message}. Error:${errorMessage}`)
 }

 args.forEach(arg => {
   if (_.isError(arg)) {
     HoneyBadger.notify(arg)
   }
 })

    if ( !config['configPath'] ) delete config['configPath'];

    return config;

  },

  async getFile ( filePath ) {

    const content = await Utils.file.read ( filePath );

    if ( !content || !content.trim () ) return;

    const config: any = _.attempt ( JSON5.parse, content );

    if ( _.isError ( config ) ) {

      const option = await vscode.window.showErrorMessage ( '[{{displayName}}] Your configuration file contains improperly formatted JSON', { title: 'Overwrite' }, { title: 'Edit' } );

      if ( option && option.title === 'Overwrite' ) {

        await Utils.file.write ( filePath, '{}' );

        return {};

      } else {

        if ( option && option.title === 'Edit' ) {

          Utils.file.open ( filePath );