ÿØÿà JFIF    ÿÛ „  ( %"1!%)+...383,7(-.+  -+++--++++---+-+-----+---------------+---+-++7-----ÿÀ  ß â" ÿÄ     ÿÄ H    !1AQaq"‘¡2B±ÁÑð#R“Ò Tbr‚²á3csƒ’ÂñDS¢³$CÿÄ   ÿÄ %  !1AQa"23‘ÿÚ   ? ôÿ ¨pŸªáÿ —åYõõ\?àÒü©ŠÄï¨pŸªáÿ —åYõõ\?àÓü©ŠÄá 0Ÿªáÿ Ÿå[úƒ ú®ði~TÁbqÐ8OÕpÿ ƒOò¤Oè`–RÂáœá™êi€ßÉ< FtŸI“öÌ8úDf´°å}“¾œ6  öFá°y¥jñÇh†ˆ¢ã/ÃÐ:ªcÈ "Y¡ðÑl>ÿ ”ÏËte:qž\oäŠe÷󲍷˜HT4&ÿ ÓÐü6ö®¿øþßèô Ÿ•7Ñi’•j|“ñì>b…þS?*Óôÿ ÓÐü*h¥£ír¶ü UãSç‚Ÿ[AÐaè[ûª•õ&õj?†Éö+EzP—WeÒírJFt ‘BŒ†Ï‡%#tE Øz ¥OÛ«!1›üä±Í™%ºÍãö]°î(–:@<‹ŒÊö×òÆt¦ãº+‡¦%ÌÁ²h´OƒJŒtMÜ>ÀÜÊw3Y´•牋4ǍýʏTì>œú=Íwhyë,¾Ôò×õ¿ßÊa»«þˆѪQ|%6ž™A õ%:øj<>É—ÿ Å_ˆCbõ¥š±ý¯Ýƒï…¶|RëócÍf溪“t.СøTÿ *Ä¿-{†çàczůŽ_–^XþŒ±miB[X±d 1,é”zEù»& î9gœf™9Ð'.;—™i}!ôšåîqêÛ٤ёý£½ÆA–àôe"A$˝Úsäÿ ÷Û #°xŸëí(l »ý3—¥5m! rt`†0~'j2(]S¦¦kv,ÚÇ l¦øJA£Šƒ J3E8ÙiŽ:cÉžúeZ°€¯\®kÖ(79«Ž:¯X”¾³Š&¡* ….‰Ž(ÜíŸ2¥ª‡×Hi²TF¤ò[¨íÈRëÉ䢍mgÑ.Ÿ<öäS0í„ǹÁU´f#Vß;Õ–…P@3ío<ä-±»Ž.L|kªÀê›fÂ6@»eu‚|ÓaÞÆŸ…¨ááå>åŠ?cKü6ùTÍÆ”†sĤÚ;H2RÚ†õ\Ö·Ÿn'¾ ñ#ºI¤Å´%çÁ­‚â7›‹qT3Iï¨ÖÚ5I7Ë!ÅOóŸ¶øÝñØôת¦$Tcö‘[«Ö³šÒ';Aþ ¸èíg A2Z"i¸vdÄ÷.iõ®§)¿]¤À†–‡É&ä{V¶iŽ”.Ó×Õÿ û?h¬Mt–íª[ÿ Ñÿ ÌV(í}=ibÔ¡›¥¢±b Lô¥‡piη_Z<‡z§èŒ)iÖwiÇ 2hÙ3·=’d÷8éŽ1¦¸c¤µ€7›7Ø ð\á)} ¹fËí›pAÃL%âc2 í§æQz¿;T8sæ°qø)QFMð‰XŒÂ±N¢aF¨…8¯!U  Z©RÊ ÖPVÄÀÍin™Ì-GˆªÅËŠ›•zË}º±ŽÍFò¹}Uw×#ä5B¤{î}Ð<ÙD é©¤&‡ïDbàÁôMÁ." ¤‡ú*õ'VŽ|¼´Úgllº¼klz[Æüï÷Aób‡Eÿ dÑ»Xx9ÃÜ£ÁT/`¼¸vI±Ýµ·Ë‚“G³þ*Ÿû´r|*}<¨îºœ @¦mÄ’M¹”.œ«Y–|6ÏU¤jç¥ÕÞqO ˜kDÆÁ¨5ÿ š;Њ¦¦€GÙk \ –Þ=â¼=SͧµªS°ÚÍpÜãQűÀõ¬?ÃÁ1Ñ•õZà?hóœ€ L¦l{Y*K˜Ù›zc˜–ˆâ ø+¾ ­-Ök¥%ùEÜA'}ˆ><ÊIè“bpÍ/qÞâvoX€w,\úªò6Z[XdÒæ­@Ö—€$òJí#é>'°Ú ôª˜<)4ryÙ£|óAÅn5žêŸyÒäMÝ2{"}‰–¤l÷ûWX\l¾Á¸góÉOÔ /óñB¤f¸çñ[.P˜ZsÊË*ßT܈§QN¢’¡¨§V¼(Üù*eÕ“”5T¨‹Âê¥FŒã½Dü[8'Ò¥a…Ú¶k7a *•›¼'Ò·\8¨ª\@\õ¢¦íq+DÙrmÎ…_ªæ»ŠÓœ¡¯’Ré9MÅ×D™lælffc+ŒÑ,ý™ÿ ¯þǤ=Å’Á7µ÷ÚÛ/“Ü€ñýã¼àí¾ÕÑ+ƒ,uµMâÀÄbm:ÒÎPæ{˜Gz[ƒ¯«® KHà`ßØŠéí¯P8Aq.C‰ à€kòpj´kN¶qô€…Õ,ÜNŠª-­{Zö’æû44‰sŽè‰îVíRœÕm" 6?³D9¡ÇTíÅꋇ`4«¸ÝÁô ï’ýorqКÇZ«x4Žâéþuïf¹µö[P ,Q£éaX±`PÉÍZ ¸äYúg üAx ’6Lê‚xÝÓ*äQ  Ï’¨hÍ =²,6ï#rÃ<¯–£»ƒ‹,–ê•€ aÛsñ'%Æ"®ÛüìBᝠHÚ3ß°©$“XnœÖ’î2ËTeûìxîß ¦å¿çÉ ðK§þ{‘t‚Ϋ¬jéîZ[ ”š7L¥4VÚCE×]m¤Øy”ä4-dz£œ§¸x.*ãÊÊ b÷•h:©‡¦s`BTÁRû¾g⻩‹jø sF¢àJøFl‘È•Xᓁà~*j¯ +(ÚÕ6-£¯÷GŠØy‚<Ç’.F‹Hœw(+)ÜÜâÈzÄäT§FߘãÏ;DmVœ3Àu@mÚüXÝü•3B¨òÌÁÛ<·ÃÜ z,Ì@õÅ·d2]ü8s÷IôÞ¯^Ç9¢u„~ëAŸï4«M? K]­ÅàPl@s_ p:°¬ZR”´›JC[CS.h‹ƒïËœ«Æ]–÷ó‚wR×k7X‰k›‘´ù¦=¡«‰¨¨Â')—71ó’c‡Ðúµ `é.{§p¹ój\Ž{1h{o±Ý=áUÊïGÖŒõ–-BÄm+AZX¶¡ ïHðæ¥JmÙ;…ä¡Ÿˆ¦ ° äšiÉg«$üMk5¤L“’çÊvïâï ,=f“"íἊ5ô¬x6{ɏžID0e¸vçmi'︧ºð9$ò¹÷*£’9ÿ ²TÔ…×>JV¥}Œ}$p[bÔ®*[jzS*8 ”·T›Í–ñUîƒwo$áè=LT™ç—~ô·¤ÈÚ$榍q‰„+´kFm)ž‹©i–ËqÞŠ‰à¶ü( ‚•§ •°ò·‡#5ª•µÊ﯅¡X¨šÁ*F#TXJÊ ušJVÍ&=iÄs1‚3•'fý§5Ñ<=[íÞ­ PÚ;ѱÌ_~Ä££8rÞ ²w;’hDT°>ÈG¬8Á²ÚzŽ®ò®qZcqJêäÞ-ö[ܘbň±çb“Š¶31²n×iƒðÕ;1¶þÉ ªX‰,ßqÏ$>•î íZ¥Z 1{ç൵+ƒÕµ¥°T$§K]á»Ûï*·¤tMI’ÂZbŽÕiÒ˜}bÓ0£ª5›¨ [5Ž^ÝœWøÂÝh° ¢OWun£¤5 a2Z.G2³YL]jåtì”ä ÁÓ‘%"©<ÔúÊ°sº UZvä‡ÄiÆÒM .÷V·™ø#kèýiíÌ–ª)µT[)BˆõÑ xB¾B€ÖT¨.¥~ð@VĶr#¸ü*åZNDŽH;âi ],©£öØpù(šºãö¼T.uCê•4@ÿ GÕÛ)Cx›®0ø#:ÏðFÒbR\(€€Ä®fã4Þ‰Fä¯HXƒÅ,†öEÑÔÜ]Öv²?tLÃvBY£ú6Êu5ÅAQ³1‘’¬x–HŒÐ‡ ^ ¸KwJôÖŽ5×CÚ¨vÜ«/B0$×k°=ðbÇ(Ï)w±A†Á† 11Í=èQšµ626ŒÜ/`G«µ<}—-Ö7KEHÈÉðóȤmݱû±·ø«Snmá=“ä«šmݱŸ¡¶~ó·“äUóJæúòB|E LêŽy´jDÔ$G¢þÐñ7óR8ýÒ…Ç› WVe#·Ÿ p·Fx~•ݤF÷0Èÿ K¯æS<6’¡WШ; ´ÿ ¥Êø\Òuî†åÝ–VNœkÒ7oòX¨Á­Ø÷FÎÑä±g÷ÿ M~Çî=p,X´ ÝÌÚÅ‹’ÃjÖ.ØöÏñ qïQ¤ÓZE†° =6·]܈ s¸>v•Ž^Ý\wq9r‰Î\¸¡kURÒ$­*‹Nq?Þª*!sŠÆ:TU_u±T+øX¡ ®¹¡,ÄâÃBTsÜ$Ø›4m椴zÜK]’’›Pƒ @€#â˜`é¹=I‡fiV•Ôî“nRm+µFPOhÍ0B£ €+¬5c v•:P'ÒyÎ ‰V~‚Ó†ÖuókDoh$å\*ö%Ю=£«…aȼ½÷Û.-½VŒŠ¼'lyî±1¬3ó#ÞE¿ÔS¤gV£m›=§\û"—WU¤ÚǼÿ ÂnÁGŒÃ ‚õN D³õNÚíŒÕ;HôyÄÈ©P¹Ä{:?R‘Ô¨âF÷ø£bÅó® JS|‚R÷ivýáâ€Æé¡è³´IئÑT!§˜•Øª‚¬â@q€wnïCWÄ@JU€ê¯m6]Ï:£âx'+ÒðXvÓ¦Úm=–´7œ $ì“B£~p%ÕŸUþ« N@¼üï~w˜ñø5®—'Ôe»¤5ã//€ž~‰Tþ›Å7•#¤× Íö pÄ$ùeåì*«ÓŠEØWEÈsßg ¦ûvžSsLpºÊW–âµEWöˬH; ™!CYõZ ÃÄf æ#1W. \uWâ\,\Çf j’<qTbên›Î[vxx£ë 'ö¨1›˜ÀM¼Pÿ H)ƒêêŒA7s,|F“ 꺸k³9Ìö*ç®;Ö!Ö$Eiž•¹ÒÚ†ýóéÝû¾ÕS®ó$’NÝäŸz¤5r¦ãÄÃD÷Üø!°ø‡Ô&@m™Ì^Ãä­d q5Lnÿ N;.6½·N|#ä"1Nƒx“ã<3('&ñßt  ~ªu”1Tb㫨9ê–›–bìd$ߣ=#ÕãÒmU¯eí$EFù5ýYô櫨æ왍Ǘ±ssM]·á¿0ÕåJRÓªîiƒ+O58ÖñªŠÒx" \µâá¨i’¤i —Ö ” M+M¤ë9‚‰A¦°Qõ¾ßøK~¼Ã‘g…Ö´~÷Ï[3GUœÒ½#…kàÔ®Ò”‰³·dWV‰IP‰Ú8u¹”E ÖqLj¾êÕCBš{A^Âß;–¨`¯¬ìö ˼ ×tìø.tƐm*n¨y4o&Àx¥n¦×î‡aupáÛj8¿m›è¶ã!o½;ß0y^ý×^EÑ¿ÒjzŒ­)vÚÑnÄL …^ªô× ‡—‚3k Îý­hï]içå–îÏ*÷ñþ»Ô CÒjøjÍznˆ´ ¹#b'Fô‹ ‰v¥'’à'T´ƒHýÍ%M‰ ƒ&ÆÇŒï1 ‘ –Þ ‰i¬s žR-Ÿ kŠ¬á¬7:þ 0ŒÅÒÕ/aÙ¬ÃÝ#Úøœ ©aiVc‰. ¹¦ãµ” ›Yg¦›ÆÎýº°f³7ƒhá·¸­}&D9¡ÂsÉÙÞèŠõØàC™¨ñbFC|´Ü(ŸƒÚÒ-%»'a Ì¿)ËÇn¿úÿ ÞŽX…4ÊÅH^ôΑí@ù¹Eh¶“L8Çjù ¼ÎåVªóR©Ï5uà V4lZß®=€xÖŸ–ÑÈ ÷”¨°¾__yM1tÉ?uÆþIkÄgæ@þ[¢†°XÃJ£j·:nkÅ¢u ‘}âGzö­/IµèŠ¬¼48q¦F°ŽR¼=ûì{´¯RýicS ÕÛ íNtÍÙï£,w4rêì®»~x(©Uñ§#Ñ&œÕ¤>ÎåÍÓ9’Ö{9eV­[Öjâ²ãu]˜å2›qÑšÕJç0€sÄ|Êëè0튔bÁ>“{×_F`Ø©ºê:µä,v¤ðfc1±"«ÔÍän1#=· Âøv~H½ÐßA¾¿Ü€Óš]Õ; I¾÷ç‚Qi†î¹9ywÔKG˜áñ zQY—§ÃÕZ07§X‚ Áh;ÁM)iÌCH-¯T‘ë|A0{Ò½LÚ–TâÖkÜ’dÀ“rmm»”جPF³ÖcbE§T€ÒxKºû’Ó®7±²(\4ŽÃ¸Uu@j™yĵ;³µ!Á¢b.W¤=mõ´êµK k ¸K^ÜÛ#p*Ü14qkZç5ïë †°5Ï%ÍÛ<Õ¤×Ô¥ê†C Õ´¼ú$ƒÖ“”]Ù¬qÞÚ[4©ý!ûÏ—Áb쳐XµA¬â~`›Çr¸8ìùÝ䫦<>ä÷«?xs´ÇÑ /á;¹øüÊÈÙà{"@Žïzâ¬[âß‚ U_<ÇŸ½4èN˜ú61®qŠu ¦þF£»äJ_ˆÙÎ~ ÞAã–Ý„Ï—rŠD;xTž‘ô`É«…suãO`?³à™ô Lý#Íc5öoæØ‚y´´÷«ZR§<&JÇ+éâô´€i!Àˆ0æAoàðLèÖ-2ŸõW.’t^–(KÁmHµV@xÜÇy®Ñø­â^:Ú3w· 7½¹°ñ¸â¹®:',«Mœ—n­Á+Ãbš LÈ‘ÄnRÓÅœ%¦²‰¨ùQ:¤f‚ "PÕtô¸…cæl…&˜Ú˜Ôkv‹ž+vŠ,=¢v­6—Xy*¥t£«<™:“aîϲ=¦6rO]XI¿Œ÷¤zÚ­›¶ 6÷”w\d ü~v®ˆÌk«^m<ÿ ¢‰Õ\)ùºŽ;… lîÙÅEŠ®cѾ@vnMÏ,¼“ñ•ŽBxðÃzãÇç%3ˆ"}Ù•Åî> BÉú;Ò]V+P˜F_´ßé> Øše|ï‡ÄOmFæÇ ãqÞ$/xÐx­z`ï9"œÜij‚!7.\Td…9M‡•iŽ‹¾‘50ÞŽn¥ß4ÉôO ¹*í^QêËÜÇÌ8=Ž§s‰'ÂëÙ«á%Pú[O †ÅP¯VsŽ°.‰,kc¶ ¬A9n˜XÎ-ÞšN["¹QÕ‰ƒMýÁߺXJæÍaLj¾×Ãmã¾ãÚ uñÒþåQô¦¥ /ÄUx:‚ÍÜ’ Đ©ØÝ3V¨‰ÕnÐ6ó*óúK­«…c ¯U òhsý­jóÔj#,ímŒRµ«lbïUTŒÑ8†Ä0œÏr`ð¡¬É Ї ë"À² ™ 6¥ f¶ ¢ÚoܱԷ-<Àî)†a¶ž'Ú»¨TXqØæ¶÷YÄHy˜9ÈIW­YÀuMFë ºÏ’AqÌ4·/Ú †ô'i$øä­=Ä Ý|öK×40è|È6p‘0§)o¥ctî§H+CA-“ xØ|ÐXŠç l8íºð3Ø:³¤¬KX¯UÿÙ /** * Support for concurrent task management and synchronization in web * applications. * * @author Dave Longley * @author David I. Lehn * * Copyright (c) 2009-2013 Digital Bazaar, Inc. */ var forge = require('./forge'); require('./debug'); require('./log'); require('./util'); // logging category var cat = 'forge.task'; // verbose level // 0: off, 1: a little, 2: a whole lot // Verbose debug logging is surrounded by a level check to avoid the // performance issues with even calling the logging code regardless if it // is actually logged. For performance reasons this should not be set to 2 // for production use. // ex: if(sVL >= 2) forge.log.verbose(....) var sVL = 0; // track tasks for debugging var sTasks = {}; var sNextTaskId = 0; // debug access forge.debug.set(cat, 'tasks', sTasks); // a map of task type to task queue var sTaskQueues = {}; // debug access forge.debug.set(cat, 'queues', sTaskQueues); // name for unnamed tasks var sNoTaskName = '?'; // maximum number of doNext() recursions before a context swap occurs // FIXME: might need to tweak this based on the browser var sMaxRecursions = 30; // time slice for doing tasks before a context swap occurs // FIXME: might need to tweak this based on the browser var sTimeSlice = 20; /** * Task states. * * READY: ready to start processing * RUNNING: task or a subtask is running * BLOCKED: task is waiting to acquire N permits to continue * SLEEPING: task is sleeping for a period of time * DONE: task is done * ERROR: task has an error */ var READY = 'ready'; var RUNNING = 'running'; var BLOCKED = 'blocked'; var SLEEPING = 'sleeping'; var DONE = 'done'; var ERROR = 'error'; /** * Task actions. Used to control state transitions. * * STOP: stop processing * START: start processing tasks * BLOCK: block task from continuing until 1 or more permits are released * UNBLOCK: release one or more permits * SLEEP: sleep for a period of time * WAKEUP: wakeup early from SLEEPING state * CANCEL: cancel further tasks * FAIL: a failure occured */ var STOP = 'stop'; var START = 'start'; var BLOCK = 'block'; var UNBLOCK = 'unblock'; var SLEEP = 'sleep'; var WAKEUP = 'wakeup'; var CANCEL = 'cancel'; var FAIL = 'fail'; /** * State transition table. * * nextState = sStateTable[currentState][action] */ var sStateTable = {}; sStateTable[READY] = {}; sStateTable[READY][STOP] = READY; sStateTable[READY][START] = RUNNING; sStateTable[READY][CANCEL] = DONE; sStateTable[READY][FAIL] = ERROR; sStateTable[RUNNING] = {}; sStateTable[RUNNING][STOP] = READY; sStateTable[RUNNING][START] = RUNNING; sStateTable[RUNNING][BLOCK] = BLOCKED; sStateTable[RUNNING][UNBLOCK] = RUNNING; sStateTable[RUNNING][SLEEP] = SLEEPING; sStateTable[RUNNING][WAKEUP] = RUNNING; sStateTable[RUNNING][CANCEL] = DONE; sStateTable[RUNNING][FAIL] = ERROR; sStateTable[BLOCKED] = {}; sStateTable[BLOCKED][STOP] = BLOCKED; sStateTable[BLOCKED][START] = BLOCKED; sStateTable[BLOCKED][BLOCK] = BLOCKED; sStateTable[BLOCKED][UNBLOCK] = BLOCKED; sStateTable[BLOCKED][SLEEP] = BLOCKED; sStateTable[BLOCKED][WAKEUP] = BLOCKED; sStateTable[BLOCKED][CANCEL] = DONE; sStateTable[BLOCKED][FAIL] = ERROR; sStateTable[SLEEPING] = {}; sStateTable[SLEEPING][STOP] = SLEEPING; sStateTable[SLEEPING][START] = SLEEPING; sStateTable[SLEEPING][BLOCK] = SLEEPING; sStateTable[SLEEPING][UNBLOCK] = SLEEPING; sStateTable[SLEEPING][SLEEP] = SLEEPING; sStateTable[SLEEPING][WAKEUP] = SLEEPING; sStateTable[SLEEPING][CANCEL] = DONE; sStateTable[SLEEPING][FAIL] = ERROR; sStateTable[DONE] = {}; sStateTable[DONE][STOP] = DONE; sStateTable[DONE][START] = DONE; sStateTable[DONE][BLOCK] = DONE; sStateTable[DONE][UNBLOCK] = DONE; sStateTable[DONE][SLEEP] = DONE; sStateTable[DONE][WAKEUP] = DONE; sStateTable[DONE][CANCEL] = DONE; sStateTable[DONE][FAIL] = ERROR; sStateTable[ERROR] = {}; sStateTable[ERROR][STOP] = ERROR; sStateTable[ERROR][START] = ERROR; sStateTable[ERROR][BLOCK] = ERROR; sStateTable[ERROR][UNBLOCK] = ERROR; sStateTable[ERROR][SLEEP] = ERROR; sStateTable[ERROR][WAKEUP] = ERROR; sStateTable[ERROR][CANCEL] = ERROR; sStateTable[ERROR][FAIL] = ERROR; /** * Creates a new task. * * @param options options for this task * run: the run function for the task (required) * name: the run function for the task (optional) * parent: parent of this task (optional) * * @return the empty task. */ var Task = function(options) { // task id this.id = -1; // task name this.name = options.name || sNoTaskName; // task has no parent this.parent = options.parent || null; // save run function this.run = options.run; // create a queue of subtasks to run this.subtasks = []; // error flag this.error = false; // state of the task this.state = READY; // number of times the task has been blocked (also the number // of permits needed to be released to continue running) this.blocks = 0; // timeout id when sleeping this.timeoutId = null; // no swap time yet this.swapTime = null; // no user data this.userData = null; // initialize task // FIXME: deal with overflow this.id = sNextTaskId++; sTasks[this.id] = this; if(sVL >= 1) { forge.log.verbose(cat, '[%s][%s] init', this.id, this.name, this); } }; /** * Logs debug information on this task and the system state. */ Task.prototype.debug = function(msg) { msg = msg || ''; forge.log.debug(cat, msg, '[%s][%s] task:', this.id, this.name, this, 'subtasks:', this.subtasks.length, 'queue:', sTaskQueues); }; /** * Adds a subtask to run after task.doNext() or task.fail() is called. * * @param name human readable name for this task (optional). * @param subrun a function to run that takes the current task as * its first parameter. * * @return the current task (useful for chaining next() calls). */ Task.prototype.next = function(name, subrun) { // juggle parameters if it looks like no name is given if(typeof(name) === 'function') { subrun = name; // inherit parent's name name = this.name; } // create subtask, set parent to this task, propagate callbacks var subtask = new Task({ run: subrun, name: name, parent: this }); // start subtasks running subtask.state = RUNNING; subtask.type = this.type; subtask.successCallback = this.successCallback || null; subtask.failureCallback = this.failureCallback || null; // queue a new subtask this.subtasks.push(subtask); return this; }; /** * Adds subtasks to run in parallel after task.doNext() or task.fail() * is called. * * @param name human readable name for this task (optional). * @param subrun functions to run that take the current task as * their first parameter. * * @return the current task (useful for chaining next() calls). */ Task.prototype.parallel = function(name, subrun) { // juggle parameters if it looks like no name is given if(forge.util.isArray(name)) { subrun = name; // inherit parent's name name = this.name; } // Wrap parallel tasks in a regular task so they are started at the // proper time. return this.next(name, function(task) { // block waiting for subtasks var ptask = task; ptask.block(subrun.length); // we pass the iterator from the loop below as a parameter // to a function because it is otherwise included in the // closure and changes as the loop changes -- causing i // to always be set to its highest value var startParallelTask = function(pname, pi) { forge.task.start({ type: pname, run: function(task) { subrun[pi](task); }, success: function(task) { ptask.unblock(); }, failure: function(task) { ptask.unblock(); } }); }; for(var i = 0; i < subrun.length; i++) { // Type must be unique so task starts in parallel: // name + private string + task id + sub-task index // start tasks in parallel and unblock when the finish var pname = name + '__parallel-' + task.id + '-' + i; var pi = i; startParallelTask(pname, pi); } }); }; /** * Stops a running task. */ Task.prototype.stop = function() { this.state = sStateTable[this.state][STOP]; }; /** * Starts running a task. */ Task.prototype.start = function() { this.error = false; this.state = sStateTable[this.state][START]; // try to restart if(this.state === RUNNING) { this.start = new Date(); this.run(this); runNext(this, 0); } }; /** * Blocks a task until it one or more permits have been released. The * task will not resume until the requested number of permits have * been released with call(s) to unblock(). * * @param n number of permits to wait for(default: 1). */ Task.prototype.block = function(n) { n = typeof(n) === 'undefined' ? 1 : n; this.blocks += n; if(this.blocks > 0) { this.state = sStateTable[this.state][BLOCK]; } }; /** * Releases a permit to unblock a task. If a task was blocked by * requesting N permits via block(), then it will only continue * running once enough permits have been released via unblock() calls. * * If multiple processes need to synchronize with a single task then * use a condition variable (see forge.task.createCondition). It is * an error to unblock a task more times than it has been blocked. * * @param n number of permits to release (default: 1). * * @return the current block count (task is unblocked when count is 0) */ Task.prototype.unblock = function(n) { n = typeof(n) === 'undefined' ? 1 : n; this.blocks -= n; if(this.blocks === 0 && this.state !== DONE) { this.state = RUNNING; runNext(this, 0); } return this.blocks; }; /** * Sleep for a period of time before resuming tasks. * * @param n number of milliseconds to sleep (default: 0). */ Task.prototype.sleep = function(n) { n = typeof(n) === 'undefined' ? 0 : n; this.state = sStateTable[this.state][SLEEP]; var self = this; this.timeoutId = setTimeout(function() { self.timeoutId = null; self.state = RUNNING; runNext(self, 0); }, n); }; /** * Waits on a condition variable until notified. The next task will * not be scheduled until notification. A condition variable can be * created with forge.task.createCondition(). * * Once cond.notify() is called, the task will continue. * * @param cond the condition variable to wait on. */ Task.prototype.wait = function(cond) { cond.wait(this); }; /** * If sleeping, wakeup and continue running tasks. */ Task.prototype.wakeup = function() { if(this.state === SLEEPING) { cancelTimeout(this.timeoutId); this.timeoutId = null; this.state = RUNNING; runNext(this, 0); } }; /** * Cancel all remaining subtasks of this task. */ Task.prototype.cancel = function() { this.state = sStateTable[this.state][CANCEL]; // remove permits needed this.permitsNeeded = 0; // cancel timeouts if(this.timeoutId !== null) { cancelTimeout(this.timeoutId); this.timeoutId = null; } // remove subtasks this.subtasks = []; }; /** * Finishes this task with failure and sets error flag. The entire * task will be aborted unless the next task that should execute * is passed as a parameter. This allows levels of subtasks to be * skipped. For instance, to abort only this tasks's subtasks, then * call fail(task.parent). To abort this task's subtasks and its * parent's subtasks, call fail(task.parent.parent). To abort * all tasks and simply call the task callback, call fail() or * fail(null). * * The task callback (success or failure) will always, eventually, be * called. * * @param next the task to continue at, or null to abort entirely. */ Task.prototype.fail = function(next) { // set error flag this.error = true; // finish task finish(this, true); if(next) { // propagate task info next.error = this.error; next.swapTime = this.swapTime; next.userData = this.userData; // do next task as specified runNext(next, 0); } else { if(this.parent !== null) { // finish root task (ensures it is removed from task queue) var parent = this.parent; while(parent.parent !== null) { // propagate task info parent.error = this.error; parent.swapTime = this.swapTime; parent.userData = this.userData; parent = parent.parent; } finish(parent, true); } // call failure callback if one exists if(this.failureCallback) { this.failureCallback(this); } } }; /** * Asynchronously start a task. * * @param task the task to start. */ var start = function(task) { task.error = false; task.state = sStateTable[task.state][START]; setTimeout(function() { if(task.state === RUNNING) { task.swapTime = +new Date(); task.run(task); runNext(task, 0); } }, 0); }; /** * Run the next subtask or finish this task. * * @param task the task to process. * @param recurse the recursion count. */ var runNext = function(task, recurse) { // get time since last context swap (ms), if enough time has passed set // swap to true to indicate that doNext was performed asynchronously // also, if recurse is too high do asynchronously var swap = (recurse > sMaxRecursions) || (+new Date() - task.swapTime) > sTimeSlice; var doNext = function(recurse) { recurse++; if(task.state === RUNNING) { if(swap) { // update swap time task.swapTime = +new Date(); } if(task.subtasks.length > 0) { // run next subtask var subtask = task.subtasks.shift(); subtask.error = task.error; subtask.swapTime = task.swapTime; subtask.userData = task.userData; subtask.run(subtask); if(!subtask.error) { runNext(subtask, recurse); } } else { finish(task); if(!task.error) { // chain back up and run parent if(task.parent !== null) { // propagate task info task.parent.error = task.error; task.parent.swapTime = task.swapTime; task.parent.userData = task.userData; // no subtasks left, call run next subtask on parent runNext(task.parent, recurse); } } } } }; if(swap) { // we're swapping, so run asynchronously setTimeout(doNext, 0); } else { // not swapping, so run synchronously doNext(recurse); } }; /** * Finishes a task and looks for the next task in the queue to start. * * @param task the task to finish. * @param suppressCallbacks true to suppress callbacks. */ var finish = function(task, suppressCallbacks) { // subtask is now done task.state = DONE; delete sTasks[task.id]; if(sVL >= 1) { forge.log.verbose(cat, '[%s][%s] finish', task.id, task.name, task); } // only do queue processing for root tasks if(task.parent === null) { // report error if queue is missing if(!(task.type in sTaskQueues)) { forge.log.error(cat, '[%s][%s] task queue missing [%s]', task.id, task.name, task.type); } else if(sTaskQueues[task.type].length === 0) { // report error if queue is empty forge.log.error(cat, '[%s][%s] task queue empty [%s]', task.id, task.name, task.type); } else if(sTaskQueues[task.type][0] !== task) { // report error if this task isn't the first in the queue forge.log.error(cat, '[%s][%s] task not first in queue [%s]', task.id, task.name, task.type); } else { // remove ourselves from the queue sTaskQueues[task.type].shift(); // clean up queue if it is empty if(sTaskQueues[task.type].length === 0) { if(sVL >= 1) { forge.log.verbose(cat, '[%s][%s] delete queue [%s]', task.id, task.name, task.type); } /* Note: Only a task can delete a queue of its own type. This is used as a way to synchronize tasks. If a queue for a certain task type exists, then a task of that type is running. */ delete sTaskQueues[task.type]; } else { // dequeue the next task and start it if(sVL >= 1) { forge.log.verbose(cat, '[%s][%s] queue start next [%s] remain:%s', task.id, task.name, task.type, sTaskQueues[task.type].length); } sTaskQueues[task.type][0].start(); } } if(!suppressCallbacks) { // call final callback if one exists if(task.error && task.failureCallback) { task.failureCallback(task); } else if(!task.error && task.successCallback) { task.successCallback(task); } } } }; /* Tasks API */ module.exports = forge.task = forge.task || {}; /** * Starts a new task that will run the passed function asynchronously. * * In order to finish the task, either task.doNext() or task.fail() * *must* be called. * * The task must have a type (a string identifier) that can be used to * synchronize it with other tasks of the same type. That type can also * be used to cancel tasks that haven't started yet. * * To start a task, the following object must be provided as a parameter * (each function takes a task object as its first parameter): * * { * type: the type of task. * run: the function to run to execute the task. * success: a callback to call when the task succeeds (optional). * failure: a callback to call when the task fails (optional). * } * * @param options the object as described above. */ forge.task.start = function(options) { // create a new task var task = new Task({ run: options.run, name: options.name || sNoTaskName }); task.type = options.type; task.successCallback = options.success || null; task.failureCallback = options.failure || null; // append the task onto the appropriate queue if(!(task.type in sTaskQueues)) { if(sVL >= 1) { forge.log.verbose(cat, '[%s][%s] create queue [%s]', task.id, task.name, task.type); } // create the queue with the new task sTaskQueues[task.type] = [task]; start(task); } else { // push the task onto the queue, it will be run after a task // with the same type completes sTaskQueues[options.type].push(task); } }; /** * Cancels all tasks of the given type that haven't started yet. * * @param type the type of task to cancel. */ forge.task.cancel = function(type) { // find the task queue if(type in sTaskQueues) { // empty all but the current task from the queue sTaskQueues[type] = [sTaskQueues[type][0]]; } }; /** * Creates a condition variable to synchronize tasks. To make a task wait * on the condition variable, call task.wait(condition). To notify all * tasks that are waiting, call condition.notify(). * * @return the condition variable. */ forge.task.createCondition = function() { var cond = { // all tasks that are blocked tasks: {} }; /** * Causes the given task to block until notify is called. If the task * is already waiting on this condition then this is a no-op. * * @param task the task to cause to wait. */ cond.wait = function(task) { // only block once if(!(task.id in cond.tasks)) { task.block(); cond.tasks[task.id] = task; } }; /** * Notifies all waiting tasks to wake up. */ cond.notify = function() { // since unblock() will run the next task from here, make sure to // clear the condition's blocked task list before unblocking var tmp = cond.tasks; cond.tasks = {}; for(var id in tmp) { tmp[id].unblock(); } }; return cond; };