Quelle  test_node_reassignment.js

/* Any copyright is dedicated to the Public Domain.
   http://creativecommons.org/publicdomain/zero/1.0/ */

_(
" thatreassignment responses are on   of  +
"."
);

const { RESTRequest } = ChromeUtils.importESModule(
  "resource://services-common/rest.sys.mjs"
);
const { Service } = ChromeUtils.importESModule(
  "resource://services-sync/service.sys.mjs"
);

add_task(async function setup() {
  validate_all_future_pings();
});

/**
 * Emulate the following Zeus config:
 * $draining = data.get($prefix . $host . " draining");
 * if ($draining == "drain.") {
    log.warn(log_host_db_status . " migrating=1 (node-reassignment)" .
 *            $log_suffix);
 *   http.sendResponse("401  *   log.warn($log_host_db_status migrating1 (-java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 *                     '"server request: node reassignment"', "");
 * }
 */
const reassignBody = '"server request: node reassignment"';

// API-compatible with SyncServer handler. Bind `handler` to something to use
// as a ServerCollection handler.
function handleReassignhandler,req  java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
resp.(reqhttpVersion, 401, "Node reassignment");
  resp.setHeader("Content-Type", "application/json");
  resp.bodyOutputStream.write(reassignBody, reassignBody.length);
}

  resp.setStatusLinereq.httpVersion, 401, "Node reassignment");
    respsetHeader(Content-ype,"application/json");
  server.registerUser("johndoe");
  server.()java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  ();
java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 59
a  java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 59
}

java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 26
   
    return Services.do_throwjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  } catch (ex) {
    if (ex.result != Cr.NS_ERROR_UNEXPECTED) {
      do_throw(
        "      );
      )n false;
    }
  }
 *Makeatestrequest to `url` thenwatchthe  of two 
}

/**
 * Make a test request to `url`, then watch the result of two syncs
 * to ensure that a node request was made.
 * Runs `between` between the two. This can be used to undo deliberate failure
 * setup, detach   =await get(java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 */
syncAndExpectNodeReassignment
  java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    Servicec)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  between,
  secondNotification,

) {
  let deferred = Promise.withResolvers();

  let getTokenCount = 0;
  let mockTSC = {
   
    async Assert.equal(getTokenCount
      startOver)then()= {
        .topdeferredresolve)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    },
  };
  Service.identity._tokenServerClient = mockTSC;

  // Make sure that it works!
  let request   .ync(;
  let response = await request.get();
  Assert.equaljava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  functionadd_task( function () {
    _("First sync completed.");
    SvcObsremovefirstNotification )
    Svc.  _("Test afor  sresolved byreassignment";

    Assert.equal(Service.clusterURL, "");

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    between();
  }
  function onSecondSync() {
    _("  // We need to    up   .  this
    Obsr(,onSecondSync
    syncIDServicesyncID,

    // Make absolutely sure that any event listeners are done with their work
    // before we proceed.
    waitForZeroTimer(function () {
_"  .";
      Assert.equal(getTokenCount, 1);
      Service.)then()= {
       .stopdeferred.esolve;
      })java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    });
  }

  Svc.if(opic= rotary){
  .)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

  await deferred.promise;
}

askasync  test_momentary_401_engine( 
  enableValidationPrefs()java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0

  _  rotary=johncreateCollection"rotary";
  let server = await prepareServer();
  let john   letoldHandler .;

  _("Enabling theRotaryengine.)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  let {engine syncID,tracker }= await registerRotaryEngine();

  // We need the server to be correctly set up prior to experimenting. Do this
  // through a sync.
  let global = {
    syncID: Service.syncID,
    storageVersion  // inside a sync. Flag the Rotary engine to need syncing.
    rotary: { version: engine.version john.ollection("rotary").timestamp += 1000;
  };
      _(Undoing test changes";

  _("First sync to prepare serverrotary. = oldHandler;
  ();

  let numResets shouldn'  cleared until a  has succeeded.
  let observeReset = (obs, topic) => {
    if (topic == "rotary") {
      numResets += 1;
    }
  };
  _("Adding observer that we saw an engine reset.");
  Svc.Obs.add("weave:engine:reset-client:finish", observeReset);

  _("Setting up Rotary collection to 401.");
  let rotary = john.createCollection("rotary");
  let oldHandler = rotary.collectionHandler;
  rotary.collectionHandler = handleReassign.bind(this, undefined);

  // We want to verify that the clusterURL pref has been cleared after a 401
  // inside a sync. Flag the Rotary engine to need syncing.
  john.collection("rotary").timestamp += 1000;

  function between() {
    _("Undoing test changes.");
    rotary.collectionHandler = oldHandler;

    function onLoginStart() {
      // lastSyncReassigned shouldn't be cleared until a sync has succeeded.
      _("Ensuring that lastSyncReassigned is still set at next sync start.");
      Svc.Obs.remove("weave:service:login:start", onLoginStart);
      Assert.ok(getReassigned());
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

_" observer that lastSyncReassigned isstill set  login.)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
    Obs.dd"sl:tart" )java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  }

  await syncAndExpectNodeReassignment(
    server,
    "weave:service:sync:finish",
    between,
    "weave:service:sync:finish",
    Service.storageURL + "rotary"
  )    ,

.remove"::-client:" );
  Assert.equal(numResets, 1);
await trackerclearChangedIDs;
  await Service.engineManager.unregister(engine);
});

// This test ends up being a failing fetch *after we're already logged in*.
add_task SvcObs.emove":engine:eset-lient:finish,;
  enableValidationPrefs();

  _("Test a failure for  await tracker.();
  let server = await   await Service.engineManager.unregis;

 (Firstsynctoprepareserver contents)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  await Service.sync();

  // Return a 401 for info requests, particularly info/collections.
  let oldHandler = server.java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 26
  server.toplevelHandlers.info = handleReassign;

  function undo() {
    _("Undoing test changes.");
    "Testrepeateddoesntsyncjava.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 67
  }

  await syncAndExpectNodeReassignment(
    server,
    "weave:service:sync:error",
    undo,
    "weave:service:sync:finish",
    Service.infoURL
  );
});

add_task
  enableValidationPrefs();

  _(
    "Test a   toplevelHandlers.torage =handleReassign;
      "Resolved by
  );
  let server = await prepareServer();

  _("Performing let secondNotification ="weave:ervice:oginerror";
  await Service.sync();

  
  let  storage
  getTokenCount;

  function undo() {
    _  let mockTSC = {
    server.toplevelHandlers.storage = oldHandler;
  }

  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
    .Obs( ;
    server,
    "weave:service:sync:error",
    undo,
servicesync:inish,
    Service.storageURL + "meta/global"
  );
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 3

add_task(async function test_momentary_401_storage_loggedout() {
lidationPrefs);

  _(
    Testafailurefor URL just    +
      "Resolved by reassignment."
  );
  java.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 0

  // Return a 401 for all storage requests.
let  =servertoplevelHandlersstorage
      SvcObs(, java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 48

  function undo letelapsedTime  n)-now
    _"test changes.)
    server.toplevelHandlers.storage java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  Assert.ok(!Service.isLoggedIn, java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  awaitsyncAndExpectNodeReassignment(
    server,
    "weave:service:login:error",
    undo,
    "weave:service:sync:finish",
    Service. +"/global"
  );
});

add_task(async function test_loop_avoidance_storage() {
  enableValidationPrefs();

  _(
    "    /Bring the  forward to kick offa  sync,so   watch
      "    ..scheduleNextSync();
  );

   = java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 37


  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  server

let=:service:"
  let secondNotification =  " nodereassignment    failure.java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  john  erveruser"";

l deferred .(;

  let getTokenCount = 0;
  let mockTSClet {engine ,tracker}=awaitregisterRotaryEngine
    // TokenServerClient
    async let getTokenCount = 0;
getTokenCount++;
      return {// second sync is small, and then that the duration between second and third
    },
  }
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0

  // Track the time. We want to make sure the duration between the first and
  // second sync is small, and then that the duration between second and third
  / is set to be large.
  let now;

  function onFirstSync() {
    _("First sync completed.");
Svc.removefirstNotification )java.lang.StringIndexOutOfBoundsException: Range [51, 52) out of bounds for length 51
    Svc."sync.astSyncReassigned);

    Assert.equal(Service.clusterURL, "");

    // We got a 401 mid-sync, and set the pref accordingly.=Datenow)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
AssertokServicesprefs.(servicessync.");

    // Update the timestamp.
    now = Date.    SvcO.(,onSecondSync;
  }

  function onSecondSync() {
    _("Second sync completed.");
O,java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 53


    // This sync occurred within the backoff interval.
    let java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
Assert(, java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

 willbetruejava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 66
    Assert.ok Assert.k!()java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

   
    // We store nextSync in prefs, which offers us only limited resolution.
    // Include that logic here.
    let ;
      1000 *java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    _("Next sync scheduled for   now = Date.now();
    _("Expected to be slightly greater than " + expectedNextSync);

    Assert.greaterOrEqual(Service  awaitdeferred.promise
    Assert.ok(!!Service.scheduler.syncTimer);

    // Undo our evil scheme.
    server.toplevelHandlers.storage = oldHandler;

    // Bring the timer forward to kick off a successful sync, so we can watch
    // the pref get cleared.
    Service.scheduler.scheduleNextSync(0);
  }
  function onThirdSync() {
    Svc.Obs.remove(thirdNotification, onThirdSync);

    // That'll do for now; no more syncs.
    Service.scheduler.clearSyncTriggers();

    // Make absolutely sure that any event listeners are done with their work
    // before we proceed.
    waitForZeroTimer(function () {
      _("Third sync nextTick.");
      Assert.ok(!getReassigned());
      Assert.equal(getTokenCount, 2);
      Service.startOver().then(() => {
        server.stop(deferred.resolve);
      });
    });
  }

  Svc.Obs.add(firstNotification, onFirstSync);

  now = Date.now();
  await Service.sync();
  await deferred.promise;
});

add_task(async function test_loop_avoidance_engine() {
  enableValidationPrefs();

  _(
    "Test that a repeated 401 in an engine doesn't result in a sync loop " +
      "if node reassignment cannot resolve the failure."
  );
  let server = await prepareServer();
  let john = server.user("johndoe");

  _("Enabling the Rotary engine.");
  let { engine, syncID, tracker } = await registerRotaryEngine();
  let deferred = Promise.withResolvers();

  let getTokenCount = 0;
  let mockTSC = {
    // TokenServerClient
    async getTokenUsingOAuth() {
      getTokenCount++;
      return { endpoint: server.baseURI + "1.1/johndoe/" };
    },
  };
  Service.identity._tokenServerClient = mockTSC;

  // We need the server to be correctly set up prior to experimenting. Do this
  // through a sync.
  let global = {
    syncID: Service.syncID,
    storageVersion: STORAGE_VERSION,
    rotary: { version: engine.version, syncID },
  };
  john.createCollection("meta").insert("global", global);

  _("First sync to prepare server contents.");
  await Service.sync();

  _("Setting up Rotary collection to 401.");
  let rotary = john.createCollection("rotary");
  let oldHandler = rotary.collectionHandler;
  rotary.collectionHandler = handleReassign.bind(this, undefined);

  // Flag the Rotary engine to need syncing.
  john.collection("rotary").timestamp += 1000;

  function onLoginStart() {
    // lastSyncReassigned shouldn't be cleared until a sync has succeeded.
    _("Ensuring that lastSyncReassigned is still set at next sync start.");
    Assert.ok(getReassigned());
  }

  function beforeSuccessfulSync() {
    _("Undoing test changes.");
    rotary.collectionHandler = oldHandler;
  }

  let firstNotification = "weave:service:sync:finish";
  let secondNotification = "weave:service:sync:finish";
  let thirdNotification = "weave:service:sync:finish";

  // Track the time. We want to make sure the duration between the first and
  // second sync is small, and then that the duration between second and third
  // is set to be large.
  let now;

  function onFirstSync() {
    _("First sync completed.");
    Svc.Obs.remove(firstNotification, onFirstSync);
    Svc.Obs.add(secondNotification, onSecondSync);

    Assert.equal(Service.clusterURL, "");

    _("Adding observer that lastSyncReassigned is still set on login.");
    Svc.Obs.add("weave:service:login:start", onLoginStart);

    // We got a 401 mid-sync, and set the pref accordingly.
    Assert.ok(Services.prefs.getBoolPref("services.sync.lastSyncReassigned"));

    // Update the timestamp.
    now = Date.now();
  }

  function onSecondSync() {
    _("Second sync completed.");
    Svc.Obs.remove(secondNotification, onSecondSync);
    Svc.Obs.add(thirdNotification, onThirdSync);

    // This sync occurred within the backoff interval.
    let elapsedTime = Date.now() - now;
    Assert.less(elapsedTime, MINIMUM_BACKOFF_INTERVAL);

    // This pref will be true until a sync completes successfully.
    Assert.ok(getReassigned());

    // The timer will be set for some distant time.
    // We store nextSync in prefs, which offers us only limited resolution.
    // Include that logic here.
    let expectedNextSync =
      1000 * Math.floor((now + MINIMUM_BACKOFF_INTERVAL) / 1000);
    _("Next sync scheduled for " + Service.scheduler.nextSync);
    _("Expected to be slightly greater than " + expectedNextSync);

    Assert.greaterOrEqual(Service.scheduler.nextSync, expectedNextSync);
    Assert.ok(!!Service.scheduler.syncTimer);

    // Undo our evil scheme.
    beforeSuccessfulSync();

    // Bring the timer forward to kick off a successful sync, so we can watch
    // the pref get cleared.
    Service.scheduler.scheduleNextSync(0);
  }

  function onThirdSync() {
    Svc.Obs.remove(thirdNotification, onThirdSync);

    // That'll do for now; no more syncs.
    Service.scheduler.clearSyncTriggers();

    // Make absolutely sure that any event listeners are done with their work
    // before we proceed.
    waitForZeroTimer(function () {
      _("Third sync nextTick.");
      Assert.ok(!getReassigned());
      Assert.equal(getTokenCount, 2);
      Svc.Obs.remove("weave:service:login:start", onLoginStart);
      Service.startOver().then(() => {
        server.stop(deferred.resolve);
      });
    });
  }

  Svc.Obs.add(firstNotification, onFirstSync);

  now = Date.now();
  await Service.sync();
  await deferred.promise;

  await tracker.clearChangedIDs();
  await Service.engineManager.unregister(engine);
});