Wait for operations

Wait for a task to complete to ensure synchronized index updates.

Required ACL: addObject

All Algolia write operations are asynchronous. When you make a request for a write operation, for example, to add or update records in your index, Algolia creates a task on a queue and returns a taskID. The task itself runs separately, depending on the server load. You can wait for a write operation to complete by using the task’s taskID and the waitTask method.

Examples

Wait until a new object is added to an index

C#

Contact contact = new Contact
{
  Firstname = "Jimmie",
  Lastname = "Barninger"
};

index.SaveObject(contact, autoGenerateObjectId: true).Wait();

// Asynchronous
var resp = await index.SaveObjectsAsync(contacts, autoGenerateObjectId: true);
resp.Wait();

type Contact struct {
	Firstname string `json:"firstname"`
	Lastname  string `json:"lastname"`
}

contact := Contact{
	Firstname: "Jimmie",
	Lastname:  "Barninger",
}

res, err := index.SaveObject(contact, opt.AutoGenerateObjectIDIfNotExist(true))
err = res.Wait()

BatchIndexingResponse resp = index.saveObject(
  new Contact().setFirstname("Jimmie").setLastname("Barninger")
);

// All objects implementing the AlgoliaWaitableResponse interface
// Can be awaited with the .waitTask() method
resp.waitTask();

const object = {
  firstname: "Jimmie",
  lastname: "Barninger",
};

index
  .saveObject(object, { autoGenerateObjectIDIfNotExist: true })
  .wait()
  .then(({ objectID }) => {
    console.log(objectID);
  });

val json = json {
    "Firstname" to "Jimmie"
    "Lastname" to "Barninger"
}

index.apply {
    saveObject(json).wait()
}

$index->addObject(
  [
    'firstname' => 'Jimmie',
    'lastname'  => 'Barninger'
  ]
)->wait();

  index.save_object(
      {"firstname": "Jimmie", "lastname": "Barninger"},
      {"autoGenerateObjectIDIfNotExist": True},
  ).wait()

# Asynchronous call and wait until complete
response = index.add_object({firstname: "Jimmie", lastname: "Barninger"})
response.wait

# Synchronous call, that handles the wait internally
index.add_object!({firstname: "Jimmie", lastname: "Barninger"})

for {
  t <- client.execute { index into "toto" `object` MyObject("test") }
  r <- client.execute { waitFor task t from "toto" }
} yield "indexing is done"

struct Contact: Codable {
  let firstName: String
  let lastName: String
}

let object = Contact(firstName: "Jimmie",
                     lastName: "Barninger")

try index.saveObject(object, autoGeneratingObjectID: true) { result in
    if case .success(let waitableWrapper) = result {
      waitableWrapper.wait() { result in
        if case .success(let response) = result {
          print("New object is indexed")
        }
      }
    }
}

If you want to ensure multiple objects have been indexed, you must check all taskIDs.

Wait for indexing of a new object and send extra HTTP header

C#

List<Contact> contacts = new List<Contact>
{
    new Contact
    {
      ObjectID = "myID1",
      Firstname = "Jimmie",
      Lastname = "Barninger"
    },
    new Contact
    {
      ObjectID = "myID2",
      Firstname = "Warren",
      Lastname = "Speach"
    }
};

RequestOptions requestOptions = new RequestOptions
{
    Headers = new Dictionary<string,string>{ { "X-Algolia-User-ID", "user123" } }
};

index.SaveObjects(contacts, requestOptions).Wait();

// Asynchronous
var resp = await index.SaveObjectsAsync(contacts, requestOptions);
resp.Wait();

type Contact struct {
	Firstname string `json:"firstname"`
	Lastname  string `json:"lastname"`
}

contact := Contact{
	Firstname: "Jimmie",
	Lastname:  "Barninger",
}

opts := []interface{}{
	opt.AutoGenerateObjectIDIfNotExist(true),
	opt.ExtraHeaders(map[string]string{"X-Algolia-User-ID": "userID2"}),
}

res, err := index.SaveObject(contact, opts...)
err = res.Wait()

BatchIndexingResponse resp = index.saveObject(
  new Contact().setFirstname("Jimmie").setLastname("Barninger"),
  new RequestOptions().addExtraHeader("X-Algolia-User-ID", "user123")
);

// All objects implementing the AlgoliaWaitableResponse interface
// Can be awaited with the .waitTask() method
resp.waitTask();

const object = {
  firstname: "Jimmie",
  lastname: "Barninger",
};

const waitRequestOptions = {
  headers: {
    "X-Forwarded-For": "94.228.178.246",
  },
};

index
  .saveObject(object, { autoGenerateObjectIDIfNotExist: true })
  .wait(waitRequestOptions)
  .then(({ objectID }) => {
    console.log(objectID);
  });

$index->addObject(
  [
    'firstname' => 'Jimmie',
    'lastname'  => 'Barninger'
  ]
)->wait([
  'X-Forwarded-For' => '94.228.178.246'
]);

index.save_object(
    {"firstname": "Jimmie", "lastname": "Barninger"},
    {"autoGenerateObjectIDIfNotExist": True},
).wait({"X-Forwarded-For": "94.228.178.246"})

extra_headers = {
  :"X-Algolia-User-ID" => "user123"
}

time_before_retry = 100

index.wait_task(res["taskID"], time_before_retry, extra_headers)

for {
  t <- client.execute { index into "toto" `object` MyObject("test") }
  r <- client.execute {
    waitFor task t from "toto" options RequestOptions(
      extraHeaders = Some(Map("X-Algolia-User-ID" => "user123"))
    )
  }
} yield "indexing is done"

struct Contact: Codable {
  let firstName: String
  let lastName: String
}

let object = Contact(firstName: "Jimmie",
                     lastName: "Barninger")

var requestOptions = RequestOptions()
requestOptions.headers = ["X-Algolia-User-ID": "user123"]

try index.saveObject(object, autoGeneratingObjectID: true) { result in
    if case .success(let waitableWrapper) = result {
      waitableWrapper.wait(requestOptions: requestOptions) { result in
        if case .success(let response) = result {
          print("New object is indexed")
        }
      }
    }
}

Parameters

taskID · string · required

Task ID of the indexing task to wait for.

requestOptions · list

A list of request options to send along with the query.