ESA: catch 401 error

I am trying to implement http digest auth with ember-simple-auth 1.0 and EmberJS 1.13. I already have a code that generates proper hash. "Authenticate" method I use to generate digest header based on login/password/method and some other parameters. "Authorize" method I use to add this header to all my requests.

The thing is I need to call "authenticate" method on any 401 response. And repeat this request with new digest header. How to implement this with ESA?

app/autheticators/digest.js

import Base from 'ember-simple-auth/authenticators/base';
import Ember from 'ember';
import CryptoJS from 'npm:crypto-js';

export default Base.extend({
    digests: {},

    restore(data) {
      //
    },

    authenticate(email, password) {
      var self = this;
      return new Ember.RSVP.Promise(function(resolve, reject) {
        var headers = {};
        if (self.get("digests")["GET"]) {
            headers[self.get("digests")["GET"].name] = self.get("digests")["GET"].value;
        }
        Ember.$.ajax({
            url: "http://ift.tt/20zaKEE",
            method: "GET",
            headers: headers
        }).then(function(response) {
            Ember.run(function() {
                resolve({email: email, password: password, digests: self.digests});
              });
        }, function(xhr, status, error) {
            console.log(xhr);
            if (xhr.status === 401) {
                if (self.get("digests")["GET"]) {
                    Ember.run(function() {
                        self.set("digests", {});
                        reject("Invalid email or password");
                    });
                } else {
                    Ember.run(function() {
                        var digestHeader = self.generateDigest(email, password, "GET", xhr.getResponseHeader("WWW-Authenticate")); // generates proper digest header
                        self.get("digests")["GET"] = digestHeader;
                        self.authenticate(email, password);
                    });
                }

            }
        });

       });
    },

    invalidate(data) {
        //
    }
});

app/authorizers/digest.js

import Base from 'ember-simple-auth/authenticators/base';
import Ember from 'ember';

export default Base.extend({  
  authorize: function(sessionData, block) {
    console.log(sessionData);
    block('Authorization', sessionData.digests);
  }
});

app/adapters/application.js

import DS from 'ember-data';
import DataAdapterMixin from 'ember-simple-auth/mixins/data-adapter-mixin';

export default DS.RESTAdapter.extend(DataAdapterMixin, {
    authorizer: 'authorizer:digest',
    host: 'http://ift.tt/1M7cqvx',
    namespace: 'rest',
    shouldReloadAll() { return true; },

    ajaxOptions() {
        const authorizer = this.get('authorizer');

        let hash = this._super(...arguments);
        let { beforeSend } = hash;

        hash.beforeSend = (xhr) => {
          this.get('session').authorize(authorizer, (headerName, headerValues) => {
            xhr.setRequestHeader(headerName, headerValues[hash.type]);
          });
          if (beforeSend) {
            beforeSend(xhr);
          }
        };
        return hash;
      }
});

app/services/ajax.js (I'm using it for any non-ember data request)

import Ember from 'ember';

export default Ember.Service.extend({
    session: Ember.inject.service('session'),

    request: function(ajaxRequestBody) {
        if (this.get('session').isAuthenticated) {
            this.get('session').authorize('authorizer:digest', (headerName, headerValue) => {
                if (ajaxRequestBody.headers) {
                    ajaxRequestBody.headers[headerName] = headerValue;
                } else {
                    var headers = {};
                    headers[headerName] = headerValue;
                    ajaxRequestBody.headers = headers;
                }

                return Ember.$.ajax(ajaxRequestBody);
            });
        } else {
            return Ember.$.ajax(ajaxRequestBody);
        }
    }
});