How to apply Promise.resolve for code that needs to be atomic

Question

I am working on a partner manager and some code need to be atomic because currently there is race condition and cant work when 2 clients calls same resource at same time. retrievePartners method returns partners and that method should me atomic. Basicaly partners are the limited resources and providing mechanism should deal only one client (asking for partner) at a time.

I have been told the code below works for atomic operation, since javascript is atomic by native.

let processingQueue = Promise.resolve();

function doStuffExclusively() {

  processingQueue = processingQueue.then(() => {
      return fetch('http://localhost', {method: 'PUT', body: ...});
  }).catch(function(e){
      throw e;
  });

  return processingQueue;
}

doStuffExclusively()
doStuffExclusively()
doStuffExclusively()

However this code is basic, my code has some await that calls another await , and so on. I want to apply that mechanism for below code but really dont know how to do, I tried few tings but no work. Can not get await work inside a then statement.

I am also confused is above code returns true in then part of processingQueue. However in my case, I return an array, or throw an error message. Should I return something to get it work as above.

Here is the function I want to make atomic just like the above code. I tried to put everything in this function in then section, before return statement, but did not worked, since

export class Workout {
  constructor (config) {
    this.instructorPeer = new jet.Peer(config)
    this.instructorPeer.connect()
  }

  async createSession (partnerInfo) {
    const partners = { chrome: [], firefox: [], safari: [], ie: [] }
    const appropriatePartners = await this.retrievePartners(partnerInfo)
    Object.keys(appropriatePartners).forEach(key => {
      appropriatePartners[key].forEach(partner => {
        const newPartner = new Partner(this.instructorPeer, partner.id)
        partners[key].push(newPartner)
      })
    })

    return new Session(partners)
  }
  async retrievePartners (capabilities) {
    const appropriatePartners = { chrome: [], firefox: [], safari: [], ie: [] }
    const partners = await this.getAllPartners()

    // first check if there is available appropriate Partners
    Object.keys(capabilities.type).forEach(key => {
      let typeNumber = parseInt(capabilities.type[key])
      for (let i = 0; i < typeNumber; i++) {
        partners.forEach((partner, i) => {
          if (
            key === partner.value.type &&
            partner.value.isAvailable &&
            appropriatePartners[key].length < typeNumber
          ) {
            appropriatePartners[key].push(partner)
            console.log(appropriatePartners[key].length)
          }
        })

        if (appropriatePartners[key].length < typeNumber) {
          throw new Error(
            'Sorry there are no appropriate Partners for this session'
          )
        }
      }
    })

    Object.keys(appropriatePartners).forEach(key => {
      appropriatePartners[key].forEach(partner => {
        this.instructorPeer.set('/partners/' + partner.id + '/states/', {
          isAvailable: false
        })
      })
    })

    return appropriatePartners
  }

  async getAllPartners (capabilities) {
    const partners = []
    const paths = await this.instructorPeer.get({
      path: { startsWith: '/partners/' }
    })
    paths.forEach((path, i) => {
      if (path.fetchOnly) {
        let obj = {}
        obj.value = path.value
        obj.id = path.path.split('/partners/')[1]
        obj.value.isAvailable = paths[i + 1].value.isAvailable
        partners.push(obj)
      }
    })
    return partners
  }

Here is the code that calls it

async function startTest () {
  const capabilities = {
    type: {
      chrome: 1
    }
  }
  const workoutServerConfig = {
    url: 'ws://localhost:8090'
  }
  const workout = createWorkout(workoutServerConfig)
  const session = await workout.createSession(capabilities)
  const session1 = await workout.createSession(capabilities)

and here is what I tried so for and not worked, session is not defined et all

let processingQueue = Promise.resolve()

    export class Workout {
  constructor (config) {
    this.instructorPeer = new jet.Peer(config)
    this.instructorPeer.connect()
this.processingQueue = Promise.resolve()
  }

  async createSession (partnerInfo) {
    this.processingQueue = this.processingQueue.then(() => {
      const partners = { chrome: [], firefox: [], safari: [], ie: [] }
      const appropriatePartners = this.retrievePartners(partnerInfo)
      Object.keys(appropriatePartners).forEach(key => {
        appropriatePartners[key].forEach(partner => {
          const newPartner = new Partner(this.instructorPeer, partner.id)
          partners[key].push(newPartner)
        })
      })

      return new Session(partners)
    })
  }

Answer 1

This is promise-based locking, based on the facts that:

1) the .then() handler will only be called once the lock has resolved.

2) once the .then() handler begins executing, no other JS code will execute, due to JS' execution model.

The overall structure of the approach you cited is correct.

The main issue I see with your code is that const appropriatePartners = this.retrievePartners(partnerInfo) will evaluate to a promise, because retrievePartners is async. You want to:

const appropriatePartners = await this.retrievePartners(partnerInfo).

This will cause your lock's executor to block on the retrievePartners call, whereas currently you are simply grabbing a promise wrapping that call's eventual return value.

Edit: See jsfiddle for an example.

In sum:

1) make the arrow function handling lock resolution async

2) make sure it awaits the return value of this.retrievePartners, otherwise you will be operating on the Promise, not the resolved value.