How to use the rsvp.defer function in rsvp

if (!updateUrl && _.includes(updateModesNeedingUrl, updateMode)) {
    throw new Error("url option must be specified for "+updateMode+" mode");
  }

  var incPath = './'+path.relative(basedir, require.resolve('./inc/index'));

  var sioPath = null;
  if (_.includes(supportModes, 'websocket')) {
    sioPath = './'+path.relative(basedir, require.resolve('socket.io-client'));
  }

  var useLocalSocketServer = !noServe && _.includes(supportModes, 'websocket');

  var server;
  var serverCommLock = {};
  var nextServerConfirm = RSVP.defer();
  function sendToServer(data) {
    return new Promise(function(resolve, reject) {
      server.stdio[3].write(JSON.stringify(data), function(err) {
        if (err) return reject(err);
        server.stdio[3].write('\n', function(err) {
          if (err) return reject(err);
          resolve();
        });
      });
    });
  }
  var runServer = _.once(function() {
    // Start a new process with an extra socket opened to it.
    // See https://github.com/nodejs/node-v0.x-archive/issues/5727 for a
    // description. It's faster than using `process.send`.
    server = cproc.spawn(

});
    }

    let expressServer =
      options._expressServer ||
      new ExpressServer({
        ui: this.ui,
        project: this.project,
        analytics: this.analytics,
        watcher,
        serverRoot,
        serverWatcher,
      });

    /* hang until the user exits */
    this._runDeferred = RSVP.defer();

    return expressServer.start(options).then(() => {
      if (hasBuild) {
        this.ui.writeLine(`– Serving on ${serveURL(options, this.project)}`);
      }
      return this._runDeferred.promise;
    });
  }

MessageWriter.prototype.get = function (name, data, cb) {
  // save callback so we can call it when receiving the reply

  var ret;
  if(typeof cb == "undefined"){
    ret = RSVP.defer();
		ret.promise.done = ret.promise.then.bind(ret.promise);
    cb = function(err, message){
      if(err) return ret.reject(err);
      ret.resolve(message);
    };
  }
  this.messageFactory("get", name, cb).send(data);
  return (ret)?ret.promise:this;
};

it('throws when child nodes escape their parent', function () {
      expect(heimdall.stack).to.eql([]);

      let deferA = defer();
      let nodeA = heimdall.node('node-a', function () {
        return deferA.promise;
      });

      expect(heimdall.stack).to.eql(['node-a']);

      let deferB = defer();
      let nodeB = heimdall.node('node-b', function () {
        return deferB.promise;
      });

      deferA.resolve();

      return expect(nodeA).to.eventually.be.rejectedWith('cannot stop: not the current node');
    });
  });

model() {
    const rsvpDefer = defer();
    const model = {};
    this.store.findAll('school').then(schools => {
      model.schools = schools;
      rsvpDefer.resolve(model);
    });
    return rsvpDefer.promise;
  },

export function yieldableToPromise(yieldable) {
  let def = defer();
  let thinInstance = {
    proceed(_index, resumeType, value) {
      if (resumeType == YIELDABLE_CONTINUE || resumeType == YIELDABLE_RETURN) {
        def.resolve(value);
      } else {
        def.reject(value);
      }
    }
  };

  let maybeDisposer = yieldable[yieldableSymbol](thinInstance, 0);
  def.promise[cancelableSymbol] = maybeDisposer || yieldable[cancelableSymbol];

  return def.promise;
}

function connectPromise(oasis, capability) {
  Logger.log("Connecting to '" + capability + "' with promise.");

  var defered = RSVP.defer();
  registerHandler(oasis, capability, {
    promise: defered.promise,
    setupCapability: function(port) {
      defered.resolve(port);
      return defered.promise;
    },
    rejectCapability: function () {
      defered.reject();
    }
  });
  return defered.promise;
}

$(this.element).on('hide.bs.modal', function() {
      let deferred = defer();

      self.unbind();

      if (self.cancel) {
        self.cancel(deferred);
      } else {
        deferred.resolve();
      }
    });
  },

QueueWorker.prototype._reject = function(taskNumber) {
  var self = this;
  var retries = 0;
  var errorString = null;
  var errorStack = null;
  var deferred = RSVP.defer();

  /**
   * Rejects the current task and changes the state to self.errorState,
   * adding additional data to the '_error_details' sub key.
   * @param {Object} error The error message or object to be logged.
   * @returns {RSVP.Promise} Whether the task was able to be rejected.
   */
  var reject = function(error) {
    if ((taskNumber !== self.taskNumber) || _.isNull(self.currentTaskRef)) {
      if (_.isNull(self.currentTaskRef)) {
        logger.debug(self._getLogEntry('Can\'t reject task - no task ' +
          'currently being processed'));
      } else {
        logger.debug(self._getLogEntry('Can\'t reject task - no longer ' +
          'processing current task'));
      }

copyDir(source, destination) {
    let defer = RSVP.defer();

    fsExtra.copy(source, destination, defer.resolve);

    return defer.promise;
  },