Redesign update API to task API

[alallema]

Breaking Changes

All the actions on indexes are now asynchronous:

• CreateIndex(), UpdateIndex(), DeleteIndex() return a Task response instead of an Index.
• index.Create and index.Delete from index return a task.
• WaitForPendingUpdate()
  • is renamed into WaitForTask
  • the current index.WaitForTask() method call /tasks/:uid
• index.GetUpdateStatus is renamed index.GetTask
• index.GetAllUpdateStatus is renamed index.GetTasks

Notes: The only two methods that now return an Index are client.Index() and client.GetIndex()

Enhancements

• new method client.WaitForTask() call /tasks/:uid
• new method client.WaitForTask()
• new method client.GetTasks that calls /tasks
• new method client.GetTask that calls /tasks/:uid

[bidoubiwa]

What is defaultWaitForTask ?

I see that it is when you provide the default values. Is this the naming convention in GO ?

[alallema]

It is the WaitForTask with default values. I don't think this naming is a specific convention in go. I can rename it if you have a better naming 🤩

[bidoubiwa]

in waitForTask you can add a structure the following way

type waitParams struct{
   interval: int,
   taskId: int
}

provide this as a parameter and in case of null use the default value?

function waitForTask(taskId: int, params WaitParams) {
   var interval = 500 // default value
   if (params.interval != 0) {
     interval = params.interval
  }
  // etc ...
}

would something like that be possible?

[alallema]

Yes, but you had to specify the last param at nil like:

	client. waitForTask(0, nil)

There is no optional parameters in golang but I can use variadic args and do something like:

func (c *Client) WaitForTask(task *Task, options ...waitParams) (*Task, error) {
	if (options == nil) {
		ctx, cancelFunc := context.WithTimeout(context.Background(), time.Second*5)
		defer cancelFunc()
		options[0].Context = ctx
		options[0].Interval = time.Millisecond*50
	}
... do waitForTask ...
}

And I can use it like:

	client. waitForTask(0)
	// OR
	client. waitForTask(0, &waitParams{ctx, time.Millisecond*10})

I'm not sure which one is the most elegant because in the second option I get the waitParams as an array.
What do you think?

[bidoubiwa]

I like the variadic args! I'm not so used to goland so I hope it is something that is not choking to the user

[bidoubiwa]

LGTM 🔥

[alallema]

I like the variadic args! I'm not so used to goland so I hope it is something that is not choking to the user

Me too!

[alallema]

bors merge

[bors]

Build succeeded:

• integration-tests (go current version)
• integration-tests (go latest version)
• linter