commit 1d2c1810eb0e2c72fabf3c239ee9b0576faaac17 · pyrox.dev/nixpkgs

+27 -23
maintainers/scripts/update.py
···

       289
       289
        
       

     

       290
       290
        
               # Prepare updater workers for each temp_dir directory.

     

       291
       291
        
               # At most `num_workers` instances of `run_update_script` will be running at one time.

     

       292
       292
       -
               updaters = asyncio.gather(

     

       293
       293
       -
                   *[

     

       294
       294
       -
                       updater(

     

       295
       295
       -
                           nixpkgs_root,

     

       296
       296
       -
                           temp_dir,

     

       297
       297
       -
                           merge_lock,

     

       298
       298
       -
                           packages_to_update,

     

       299
       299
       -
                           keep_going,

     

       300
       300
       -
                           commit,

     

       301
       301
       -
                       )

     

       302
       302
       -
                       for temp_dir in temp_dirs

     

       303
       303
       -
                   ]

     

       292
       292
       +
               updater_tasks = [

     

       293
       293
       +
                   updater(

     

       294
       294
       +
                       nixpkgs_root,

     

       295
       295
       +
                       temp_dir,

     

       296
       296
       +
                       merge_lock,

     

       297
       297
       +
                       packages_to_update,

     

       298
       298
       +
                       keep_going,

     

       299
       299
       +
                       commit,

     

       300
       300
       +
                   )

     

       301
       301
       +
                   for temp_dir in temp_dirs

     

       302
       302
       +
               ]

     

       303
       303
       +
       

     

       304
       304
       +
               tasks = asyncio.gather(

     

       305
       305
       +
                   *updater_tasks,

     

       304
       306
        
               )

     

       305
       307
        
       

     

       306
       308
        
               try:

     

       307
       309
        
                   # Start updater workers.

     

       308
       308
       -
                   await updaters

     

       310
       310
       +
                   await tasks

     

       309
       311
        
               except asyncio.exceptions.CancelledError:

     

       310
       312
        
                   # When one worker is cancelled, cancel the others too.

     

       311
       311
       -
                   updaters.cancel()

     

       313
       313
       +
                   tasks.cancel()

     

       312
       314
        
               except UpdateFailedException as e:

     

       313
       315
        
                   # When one worker fails, cancel the others, as this exception is only thrown when keep_going is false.

     

       314
       314
       -
                   updaters.cancel()

     

       316
       316
       +
                   tasks.cancel()

     

       315
       317
        
                   eprint(e)

     

       316
       318
        
                   sys.exit(1)

     

       317
       319
        
       

     

       318
       320
        
       

     

       319
       319
       -
       def main(

     

       321
       321
       +
       async def main(

     

       320
       322
        
           max_workers: int,

     

       321
       323
        
           keep_going: bool,

     

       322
       324
        
           commit: bool,

     
···

       338
       340
        
               eprint()

     

       339
       341
        
               eprint("Running update for:")

     

       340
       342
        
       

     

       341
       341
       -
               asyncio.run(start_updates(max_workers, keep_going, commit, packages))

     

       343
       343
       +
               await start_updates(max_workers, keep_going, commit, packages)

     

       342
       344
        
       

     

       343
       345
        
               eprint()

     

       344
       346
        
               eprint("Packages updated!")

     
···

       388
       390
        
           args = parser.parse_args()

     

       389
       391
        
       

     

       390
       392
        
           try:

     

       391
       391
       -
               main(

     

       392
       392
       -
                   args.max_workers,

     

       393
       393
       -
                   args.keep_going,

     

       394
       394
       -
                   args.commit,

     

       395
       395
       -
                   args.packages,

     

       396
       396
       -
                   args.skip_prompt,

     

       393
       393
       +
               asyncio.run(

     

       394
       394
       +
                   main(

     

       395
       395
       +
                       args.max_workers,

     

       396
       396
       +
                       args.keep_going,

     

       397
       397
       +
                       args.commit,

     

       398
       398
       +
                       args.packages,

     

       399
       399
       +
                       args.skip_prompt,

     

       400
       400
       +
                   )

     

       397
       401
        
               )

     

       398
       402
        
           except KeyboardInterrupt as e:

     

       399
       403
        
               # Let’s cancel outside of the main loop too.