Welcome to the Linux Foundation Forum!

lab8.2 async serial exec with util modul

Hello,

In the lab 8.2 we have to run serialy (i am not sure we say like it, means serial execution) 3 async func.
I guess we should use "Promisify" as the util module is already import in the question.
But i don't get how to use it.

i can run the code without promisify

opA((err, d) => {
        print(err, d)
        opB((e, d) => {
                print(e, d)
                opC((e,d) => {
                        print(e, d)
                })  
        })  
})

i can run it with promise

function read(x) {
        return new Promise((resolve, reject) => {
                x((e,d) => {
                        if(e) reject(print(e))          
                        resolve(print(null, d)) 
                })
        })
}
async function as() {
        await read(opA)
        await read(opB)
        await read(opC)
}
as()

But i don t understand how to run it with Promisify ???
i can promisify,

const a = promisify(opA)
const b = promisify(opB)
const c = promisify(opC)

But it does not work inside async/await, and it does not resolve, so i can not use .then().
So what am i missing, what is the point of promisify here ??

Using it with function returning promise like readFile(), i understand how it works. But in this case, using it with call-back, i don t.

Thanks if someone can explain.

Regards

ps; the code to run

const { promisify } = require('util')

const print = (err, contents) => {
  if (err) console.error(err)
  else console.log(contents)
}

const opA = (cb) => {
  setTimeout(() => {
    cb(null, 'A')
  }, 500)
}

const opB = (cb) => {
  setTimeout(() => {
    cb(null, 'B')
  }, 250)
}

const opC = (cb) => {
  setTimeout(() => {
    cb(null, 'C')
  }, 125)
}

Answers

  • I think the error handling is the part that's tripping you up:


    SPOILERS - see for code
    Given your a, b and c references:
    async function as() {
      try { 
        print(null, await a())
        print(null, await b())
        print(null, await c())
      } catch (err) {
        print(err)
      }
    }
    

    When an awaited promise rejects in an async function it can be handled in a catch block.
    In the above only the first to error will print and then execution will stop. If you wanted
    to proceed if there's an error then you'd need to try catch each one. Either way is fine
    for this exercise.

  • djedje
    djedje Posts: 20

    Thank you very much, i got it.

    ps. and Thanks for the course, It's great.

  • @djedje excellent!

This discussion has been closed.

Categories

Upcoming Training