From 329307b27c20ed25cc5c3d73d63544ee0fb46207 Mon Sep 17 00:00:00 2001 From: Willem Vanhulle Date: Sun, 11 Oct 2026 19:54:47 +0200 Subject: [PATCH] feat: font-aware glyphs, quieter tree and timeline --- docs/initrd.png | Bin 8237 -> 4924 bytes docs/shutdown.png | Bin 7150 -> 4685 bytes docs/stage-2.png | Bin 10134 -> 9704 bytes examples/demo.rs | 2 + src/console.rs | 46 ++- src/glyphs.rs | 94 +++++ src/lib.rs | 1 + src/model.rs | 174 ++++++++- src/run.rs | 9 +- src/systemd.rs | 37 +- src/view.rs | 838 ++++++++++--------------------------------- src/view/failures.rs | 40 +++ src/view/footer.rs | 73 ++++ src/view/header.rs | 37 ++ src/view/stages.rs | 128 +++++++ src/view/timeline.rs | 367 +++++++++++++++++++ src/view/tree.rs | 131 +++++++ 17 files changed, 1306 insertions(+), 671 deletions(-) create mode 100644 src/glyphs.rs create mode 100644 src/view/failures.rs create mode 100644 src/view/footer.rs create mode 100644 src/view/header.rs create mode 100644 src/view/stages.rs create mode 100644 src/view/timeline.rs create mode 100644 src/view/tree.rs diff --git a/docs/initrd.png b/docs/initrd.png index 0e8eb97238a225353a796d693e7bba3dce6a781c..979d784efb225903aa30fe5be47dda6de5d57baf 100644 GIT binary patch literal 4924 zcmeAS@N?(olHy`uVBq!ia0y~yU}a!nU{+vZW?*3G+ji*$0|SF-fKP~P-+`LnACK?Y zttP9Wm=+WAYp?#*BMbE{CS7J=5PIb4;uumf=k49@z(-jOZHZ}qtbDR>%oL6-ZQR-{ zt6gyHpSQ&mCp`fLg%1lW=iL-$R&jZ1`%t|oQbb^jM?LeI*$kagYs$_?_MPFKv-{Y+ zPZxv~0*^D4ybW9Tu^8OkwC0QV3*H@oI44oS?xdM55r8x`xvaW6Cex z<|Se;V`oT;12| zKeli6xR>)V$yAn~xM=v`ob~*${Qa-@`tCepcHrIPo;I=kwa?}}t!p^FNdAHJoGowj zZkFAsfBhkEr)TwnZ&D9@tlx|7b8om4Vt=6fc*9-O1C?xyeZ7p|uSIZ8(2nGsutaak zM*cY~-^jD)*uP%<>qmdlF59-p77FRB*lSNGeb{NlJdf9T3YzD)a(>wV?MVIGCEsjz zB%C?Oogl<0w6$Jb$KjnvgNtt0b6=P9-L96p#ahqjnO`o-i%u_nd5-mMAFRh@7Q9HFec#eJCZB2cp1+{+8?-D`mMow+VX1x z59WMjj+rO?Ao#DP;^}A1E>-dj+iborR9gM7@^|=wGiz?GKO61l&$*$x{B)?~y9JMf z<+Xy=Z@aZqtoqQ-S9VtGUM5_uO>?gGjJ!Ml`}gmUDjHT-$#1v$v{31)($_ni1QeF0 z{$2X}O50xhqqUX%H`Z<3tjc(4H@ltvfvWnlsSJDXeu>eYz5ed;wmF;Gb=GZXPnou> z+2E{QhN{E6jGMFb7a6cU$(t2jdvi`iFT2I3?GN5rB$WQyP%iT!Q~LHoe$ktCKIsoF z6z(pZ{OE(khg-MzeEjZ-p!yJcQ;v;_Z#9})R#v+G}%mTvmPZeE~upx>$C&V`i>uO~A-aZ_Xc5y{8$ zkWK9!<3lqRk1LD1)+X|t*!z_^hyVN4=U0z2vWp*>T4}~Ze(pj~pCo3^QSD@xYokFo z8gyh-hoi}c8p$S?`A>%W+OH=n3u4`wWNi7@WeGgsds|q{q_T?h!{^V7<-V+4y)!F_ zbw{;a%++@i1+g`2%qM?}f4^suE&sY#O$_%RWW8bRl;Z#J`Sa!*yc_KJ*S)$RS5OhR zaog|5YAha83>5-zGhCm4wm!AtY~sQ5Z+~93KhC(5@qC*idMl`E4?{eE{HO2RqW68g zD*yGH*qy4B$7kREnai}NP;vXa-!HcH|GQ&f^f>>kIAhs$y#v*GSL8n23$OPvIiR%h zQtxd-qAhVzYdeY|Y7>e|^&V-!%Ab+2({d zob4C8`Q!CpW}REUc1aCy7e9FRgh!6G+&(Mqabx=f{y!Q!tobY~BK!IBmzN*-`0my2 zC08U2K25fNBQYUT5UrgkXL#U>yvyYEoHL&v`_J`3aGUl0UhWTy)T8V(8qRbenrKrQ z|NWZ#PjALrBZt3M>AKrOiSzIROacauexlil(r=`xz6HT!Ee#y^m`s{+*KNabB zSm(<=cwbiZ^6SUPcQp=7fA{3d@7LGXe{#Hdezw6X`GlX#wtyJgPrt>3%lI5+HicK7w_>jDpIzA~-h&Q!np^X{F0as`|3oKD#Kxcb1}r@K~* zKd8}-`^8u`bBZ7PkKI3t8tz_-{u#znVK2@eaqlDFHGu^T`WLu2{IdOetihf6jnmz} zw{@b=*>B`{G<@EAqvXQhvRh7meT?PIIr=x^0yplymCRP*cA<|Xsxr@EVbsyXnvIzV8$kV0TJ<2?HWvm?)n=1uaS!qE9? zmcXJtYAq`sUf$SNCvR(6cJTDVr?;Fh$r%_I++|pOq>nA5{Pcm14COvNAC7c8uz1`L zWv-dI;ZDx`W?4PitNaDeUrNVUsd`+r4J@b#Wm=N|-Bj`Di_M8zx0n0-R;ix2q4cfc zjijCGe(nuhKD$gcJ8-|1;k^2Rz-q=a|IJd|1)sDXkBJE?RF^T|srU8Bev-MOJ)Sd& zqoAF^{cD`?CH`gRY&pGl{JVB8*xTmRz|K(+^4?T2p1b}JV6KF7*bbK~UWS9{e` zZpm%fmwb>I+$F`$8$9P6uam z6nwjpkv`HuI>5^Hi*P0oBt$Z4@*CSB> z&lR1E_WA$0>KcCN{yM9cFU+mOoWm6}_5ZAsn`UO~biY0M^xKnF8dcp_R|k8&GglQ*nm@I7~* z*=+OQzc)jfa@;%Y9sh{^O`B|dtl{>}I+yTU%>NWVMt_;@yUd;|FP*i*2P}K?IOFcf zWQTX_|1aP1<lF;lIU$%VyiI1{YUdT^l$*cx~AH@5=qmMbhC_W<9a8)4?U=Dd8ZT zUFvRgj!o=%`r0du4jljI5LvecRK#88-|#QzZCszediekHpGz0dm-%BjXU?_V)8_JP zzl%Lsb*r>+*=D<6KM(lc=KiqsU%6jH{Xf~gKW;32eNpcm?}mEa-}2Y*MR!T>@NC$B zp7X=~{l)uQ8$U8=r~iq0%=m7e$b-c<_Gh*yADI4VRr$f=HL3^lVj1sUd13HU`yAJY z>+9pc?)b1&O6H$b^@cy|fBsrtQGegZ?Ek+h`Tdc;tE^wxpN&r2_kO)~&x&7>s~e-O zx37D4%&zfo^6$x0w9THIa_6sK`s2m9&w}s7vzTM@(_Txj+7)EikVdMJBZ?la#dj0Ly5%1qHUZ1?K!E+bG z>G;I&uVc3FfBty?BTnCLw!`PXmb{=Bh$P-Vd;6W7hKe?_@?OpMrrle5dJ8m>+#xW50{ zYgI%Kn!_C#xUjMRf`Ewjrua^}5~D>$DEK`l79Q&T=hPTR}xW6^*ogdI(UNW8Gw)1&)<~^?@3hvI{o!D@! zA-wQ1!)^P0Z)M)S?qd#n+bheyhVRqVeW-|#q@%<&n6B7$d;3cM6N8i{z2;ltHVBlrK_v6immFohl-_OrG zew^{R_l?2>Q4Yr#54LAW2(U6bimPk)>`mDcCr{t z%Uh0nlcpto607;ViaCOTsmbK~ky+j<3+BFF9QXR(o9p`?>(>giOB~E9_ueOKbd#Ou zUd^pNb<@jdJMpb+&}_d~$MbBD$AQ^JtbZ71EV+E%ta4uMw>^=%2_bR`YUSywssc=h zmPushY3=8~5!%wQLBjt)h`fPTp|gX=5m`pZNfApj8Q;dppZy~Lb(8K93k98JZ@*mq zfA&2y(;fjV-mm2PG5_X|^Ey#>dzdxZ_!(3T_U+kQx|)My{o}>opB_FTdcR3fVA~^m z7M8#urfX*(xfgrqNu8*A`*`P?>s8jX7awHY%%5PkuVJfQuKWh!P4AiOYBa(x?Yq-n zd_b4cK-m94+C;Gr_NEFC>bV#d=La~LDlD)(t{Hy6!v4-74i4|aw#0j4Tp4q7uiuhW zVmc)BNBz!2yM*#XGa3S0878+l>p0gQc*nxhvMGh*#T#yxCHx%Th5NF9udnC&SMfUa zcgC^5cDwE^EUK!M&-dGYQIh>l7sHuFQfTpbOB)!suN2~_NR459zgYLd_E=Nb=LNI18XLloRmVRSV!VI5 z(kbsQi_$kgJKL2f?%ov-XApm!S9dR({}R)-?+@~$U)c^A2wj6!usJo>l zeChuO`Fq*(%g(iZJK@8)`zC+B^5ia)i@g^ z&%q(unrYvsMOzxyudCw;WSn~B=>Ip72i9+k{`56w)%s=4m%atXDJ+PIfAcy>{QoQc zo!*T9w}_do{SyBD^tIQwxixMG)yBShRR7ESUEqQBal7rk92_+NorwMO`uSDy_x4w7 z?=}73vHw9R%apgQb&3lfzFr=Asi-So($gL zWBujn-w8YaaO>aOs#KDVD8gjzE{=rE2HbbXS?4rA6n{wS+GyB<DN{xHv~KY#xDrnujtf2Gw~aa=!L8xW8DY&TcaGR%lh}Ias05_#JVPbPaG$U%K;u4#@Y2s z%lR#|7Kmz_G= z_qM)2*fXD5M#Q+P$btafrJ;4F3uF_K!gkbnNHshpFnTEzqymH$kr(N6Fc zSdql?XRUyNFbhv7%a+72O~&-}rX_xk4lF$!tUbj}Je>wt9{LEhHfRbM968BZ*jo6j zp)EzGr2N2@1p);;EIfrpPS?0C)H$Erl4oFQ(>cvKb3W%JD^^CuLnk?Z`aEg5aqqz< zAAw@887xI_tqok(bg&;$jo@c$(zwZVX>Oa4z$AW9$?D|C(E-9nDhuRpeyp&0pYnIu+`Vlm%UF7O?Q60Avf$PG z_NVv1TJE>D;g)^E@7A^Rb_Mydo=w~Jx9_0n`L>o zPwwNNk!Qi*yvOCa@Q31<172%IHr#D(u#R{$Nt5w5^Tvj^u~i-ip7q?bSSnB;-W|Is z;6T{!RoN2F%p5!3AJr=?a(cG4;cc&_(1x{#IBt~v6(|Vrj(zl`<&5|SdwE9wtv6Kt z{7(F_OYkg`In>ftbbMgUhB6#?d!rm zJ3fx1l6~xRE(TqkaWJZj`-Uw)^O+_w0T)FTc~A?kb&h}l2&eiSC^+KBFZc1>s;0?| zZJPQEoE&EO&udt$pm2trQM`Cp1w&vAV{?94u29F%x*g8p=T7=wYya$9sQh5&em=(o zlPW9~3v;~XnR35vt!OmZrN8=5QaUT6_aj#q?d(KforM3c>(xOu7h`dxT7tg-*A40P zN1p@*7}FndNPJ_Ip8QK?f+bT{lmkml*JR;EGMzG$MVNjmBzVr5BhcEg*#T@prT@XY zo1eKkR11roa;!QgKfJh?$L+Us_0-wcLGKIXoOWI5|J=vy9pywjW!${ zi(Ht_otS;)PTWF~mM6`i%6Eb=(;^UF!|U<(`^zJXy|?rq%;eBiO(;rXV@%`%weJcH zS(K-!D66Z?@jud{z%seD<@dQye+`(XfyBP5g?>+2AG+mX?DEbDjt3^CJZbUaS}|w( zGi3#)zDW~>jhr2xhCjHss-GXMJ|*Hnfl}i8Z9NSfGZd87Q`WGC)ZS!caXFxAROBQe zz<7G%MBz<;G=Ib}Ie8itIW_%s+2bRSFLUAUcZ>5D3R6_nRpb{)aBwVo@}z}9q~<47gd&G$*t;J$ceHLn3&2OR(eTs|8E% zL2LmTPNlV4D z`Nqi|X4@Ym{IFcHikp9n`{Of{l$#oMraWmWVb`*kS{9_$(a5PKYv0u%uBxn_GOyuO zXR{yY3@?34J&qaPZhj|X7@NJ+ZynEC#Jn?Kz+igMoC%za%_p69?OSAB7^IOfBeKW= zB79OT;H#*`)LV;JifxFq{Uj^FxcTG>PR9chEN4I_PhS2&dv7?KOi_{3tt60U<{da2@ zakB8E`RxsI96Nf}%n^8R!}7)9Kx)d<7KH}}96Ne?<_OGdS}0=)(fHRRo+Y6}RPiT^ z+2JYy0hg2KI3p)nGa0Zb{sgy(pR_b+fbgTwEeEy=&R1ty*ZaeSw;)%bfSbc@M(+n3 zMRiujbY*M*6OoPwZg!j%F3J)pFx&LGWsWGzoZdG!is?wwC(a2Mg+ZhbJQbX$&a#g0 zvPlCd;~V&MbU2}=wNqWwr}XDDodGo$!5QC}!)=DMo1aJhsl)mQcQY~z6!5h^<5WDL z%EtJ7g1J8j(>Vq(qhopOQY{vrhKAx3CpZgPa;oY$W`LAT6n?a|;p?_Aju{|z6NQ@^ zK06$+Tr*$&$UOE9Gxk(E$=$1*nj|A&6e&81e*-8NggtFxSc4o}(0t9z<1cpTGOx=N z@q!!1EG--$=LHBY61n!Ig~eU_|LTW7{x*ouQcuz2h%ixC5tW&|u7CaSD1icBKMxT} ziK?=@l}^u^8X`Zplo8p+AR(N6VAT ze;Pr-);ULjg@qX{CPA_3;sP#i6&@s7q(5P@RBV6vh3Q;xnJ z6IxN^UcZ|+DS<6ZQ7_FBRNF6XSoZ$;{G6nDSGP3OdXz2_<`kY2?O>mY=J_W%UR=H8zD4Olk)Be*<$0%c*oot@C%5U|H>q+J>nf0F3Fj-kDKI^;9 zwRG$5^LzJ)9X!d*G^;jIcNuHQ7e?_SCr10}+$*kHG5X2}C_ZrV(^znlbL07K^R$`$ z4?a9u%X=~SOo6TqYx8vBOD2VWejZQX8t;_*tK7vEFLinTr-I{*rT6*Y0&ImIl zD4?}!RyNoybO;o>Y|_)z5CAIWgg&?QG&NKoY*Sq#)~;yi-ytpHG3$7q<>Ce_u1>|X z$=m0+9;lcnV6Hdcr2lS_8{_H-hjL-Y??*gYdww-=F@8T8$-?uDGq5hkj_KXB%N##C z8`__kF!7xgUL+{6P2JGHW446TEcTq!0X7PSKR*Zw2)KB1pD@q+pu};K9W-dBsLtX7 z!XH_-_{&Y*zw^by8PCOMfLgG|%QGDuZm_Y~sJC+l6tJ#2JpZ<(N z7tQ!LWg=UVd)Z+{R+D_Yt+fubg)coglG%Dv>6Gs3pL+f?9&<>vKdENAC9w8e?N7G@ z?;IXwwAOx_<96Uz`i*0yn|Nhh57-u@G3GAGvY$NXt>UiF8jT9a1ux81PubY;Zk8n{ zWBGwbmOm~Bgo_jybNx;vF;;T5ZQWt1Sh~-BwcqTY3+0!s7Vlxc#r)A?!OS?8gjuN{ z8%(kTBtXTI07iTAsf}W>`)>)+7L&@$CK>g`yL6bGW=&cE^zCmY83|7ZRY*x%ASYa>$_7i0g~X-r`o8{VY}Xxzxp`p!3}L!rc*#rOG$ANqJL1}Wie0r3_3a75hKP8`4iJ}2*UHi}^mvt1u?Tg*@wl51Uk*n}5cft?X% zS|otl`vCPokg(3;54-iYpXB6x%y^R1l0TYjMeZ3cOT`Jxwlq9xIiR#nWJ7|V$I`jJ zj~M-r9Albxit{C_iu#irk@w7blZAtBn)OZi6C47@3+ho)$Shkb09kPhj$|g_2wMiB!*2SFvFbPt^b1 z(!%~g=}r1P0hT=~zh|nmFzTPId&cQ_zAX=4q>}2_JO3T=tmuX(_+$SwdShl3f zHgihaNLrudPM>eFl)csV#0frK0meBShUj=*w> z`wa7^IX`I;U@nd;nDZN(cO&zZ1nugihSo1f1SP!rh6P<@VbA?qG6#b3e5 zH&wW)!NBq49D(((S4gtANajdS^5^Cd200?tk7IN10Tnb?JmHS$&EtE=T;S*+uyjVl z%;g7;Iy#(4m^|T++W*6y3Nxn4F530JsdVX~O=SP*=r?~uUA z-TEse`Od2eUiACtZgSem%KAtxYn}A+P|H+V#@sbLbDDBla>S>8Gn>2Mz)G}xnzS-=*j_+ZT&fv21q^Q~_Eo2Revu<>~!I4mU({!EL%z_e-sf5xiz;tigDC#o2= z(;u)hoK~069pIergv43Y=a&rE%gEwXFup1ooVw4pSFgh_`U8Oc9 zOtpZk%SGkMIbosnrjV4Tn4V8euPoTqW^yi?y7}hXqrXqESX!pCoSCDp(#5o8*+kAF z!BgB3N11lb&U;cT!XA5+Y1XC!FEhb{cQ%TFY98^^d?uU@SiwKT+~4B{)2)CErjP5L z6d6B1)0c5%{2Cs2c~ zC3H=%M*(Y&k&Vx~_UYFz9{+OFN8tC|!eA2*!H>&@Ha0fp9rF-g?{MqHK~2pBr3)sf zUVmT;dfR9rkajKbk{jRoEXKzZYWy9f7hT;}wz1*lNvA&@FAhf3f~2l7U9%V8+Tgo7 z&GvOa+ffcl8}8r27p^5OpUl0g{8xk5M6;rdYu_2`^RF^#eP0p3my2oL!wqZ1KWyI6 zu#A6&zy~Ig3a)>#AqP_Z4<>#sFugNJVD`g{=NK3LejdJja#-c_n}rU+XI}neeca%? z^xf;^oUc91abl0qXNO?j)R~Mcd8-~YoD`mU;#a~JekCuCh@ah#0s=~1oHKL`X=n6y%cxGt9U`t zd1?O1p00P3F@oyuknIoIgP*zCm~<-lTN zrdsTDh%YiVYNINX-Jg*A>(*yT`TZ~RmjCcV=?*|>PwMVa9`(Ch*c@?{U z$4ihiue!LjBnEhooJ6036ef#%c@1DKudUx8| zr~hIyzhBLMtGUYd=U(f>cg4dC#E#fsY}Tz?#=C~~4bPtI^}CL)jefmjW!>j%`S+$4 z`DJ$BZI1H0F4R@Oh&}p`kMs?W8&WfbKHS?@xIN;)Y|X&=m)6}CVcNvOGRMGRH>-*2 zo=qGlk}A1xtljlCQjpP?|D#Ce8b7_q_uvzh6r(BNVYt0*Llpd%&n*ZXU zSn)B&w_3Fh6}Iof3(I6Sh+U8cO^@u}Uw*qhdePm>BH7>Pmdglq1#3vPE#vzH9rk4k z0{2mI&nn!jV_;dxN_g&ZsaV0&p7jhruP{B5?|8^{!>{h`iyxMefAarbd?M01b^nZG zD_v**?3sPCb1v7HJ-ZSVyPwUF`H>;ZXn)(@o8`|x>#B-3EBvZ9hB#~&i&k30z_>k8 zn6X}8@WcE2s{5PVqYkvO*00~v@KBBEUF(mTeHk|ER-2Cs|y=g!7^RbNLx%J1o z|G)709~t-UWS{O?{veg`<2E2XCHBW`+w%T z21ngr7r)0SbjL7Or`2r9_kZ|oTLb66GJ9i|D`lxG8=CzOE^K(HxuIt|$B&o&%=>&C zKD*4j$YfRT%yMVKbdHR+dFre>x7e?oyVb^YiCyQ=GNxJj_nRKtS@Yf4FQ?5l5+ zXMU9Qt>3b~i`|F!@R?S&oc}3xZc>a3IjqGm+*xI;@vl}zME$ezs&2ta{EPnZAAFU2 VTj#g-Q3eJE22WQ%mvv4FO#ngeprrr+ diff --git a/docs/shutdown.png b/docs/shutdown.png index 86a12443893391016762803610efed10c3967449..f3d18ec8d047c73f31a8c1685d0e71d6daed2dea 100644 GIT binary patch literal 4685 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 io::Result<()> { BootView { state: &state, palette: &Palette::default(), + glyphs: &Glyphs::default(), now: now(), host: "demo", frame, diff --git a/src/console.rs b/src/console.rs index 5f645c9..aca5535 100644 --- a/src/console.rs +++ b/src/console.rs @@ -1,12 +1,13 @@ -use std::fs; +use std::{collections::HashSet, fs, ptr}; use rustix::{ io::Errno, - ioctl::{Getter, IntegerSetter, Opcode, ioctl}, + ioctl::{Getter, IntegerSetter, Opcode, Updater, ioctl}, stdio::stdin, termios::ttyname, }; +const GIO_UNIMAP: Opcode = 0x4B66; const VT_GETSTATE: Opcode = 0x5603; const VT_ACTIVATE: Opcode = 0x5606; const VT_WAITACTIVE: Opcode = 0x5607; @@ -33,6 +34,47 @@ impl Drop for QuietKernelConsole { } } +#[repr(C)] +#[derive(Clone, Copy, Default)] +struct UnicodePair { + unicode: u16, + _font_position: u16, +} + +#[repr(C)] +struct UnicodeMap { + count: u16, + pairs: *mut UnicodePair, +} + +fn read_unicode_map(map: &mut UnicodeMap) -> Result<(), Errno> { + unsafe { ioctl(stdin(), Updater::::new(map)) } +} + +pub fn font_characters() -> Option> { + let mut probe = UnicodeMap { + count: 0, + pairs: ptr::null_mut(), + }; + let _ = read_unicode_map(&mut probe); + if probe.count == 0 { + return None; + } + let mut pairs = vec![UnicodePair::default(); usize::from(probe.count)]; + let mut map = UnicodeMap { + count: probe.count, + pairs: pairs.as_mut_ptr(), + }; + read_unicode_map(&mut map).ok()?; + Some( + pairs + .iter() + .take(usize::from(map.count)) + .filter_map(|pair| char::from_u32(u32::from(pair.unicode))) + .collect(), + ) +} + #[repr(C)] struct VtState { active: u16, diff --git a/src/glyphs.rs b/src/glyphs.rs new file mode 100644 index 0000000..b36d782 --- /dev/null +++ b/src/glyphs.rs @@ -0,0 +1,94 @@ +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Glyphs { + pub done: char, + pub failed: char, + pub bead: char, + pub waiting_bead: char, + pub still_going: char, + pub running_mark: char, + pub root_switch_mark: char, + pub ellipsis: &'static str, + pub chain_link: &'static str, +} + +const DONE: [char; 2] = ['√', '+']; +const FAILED: [char; 2] = ['×', 'x']; +const BEAD: [char; 2] = ['■', '#']; +const WAITING_BEAD: [char; 2] = ['·', '.']; +const STILL_GOING: [char; 2] = ['▶', '>']; +const RUNNING_MARK: [char; 3] = ['►', '▶', '>']; +const ROOT_SWITCH_MARK: [char; 2] = ['│', '|']; +const ELLIPSIS: [&str; 2] = ["…", "..."]; +const CHAIN_LINK: [&str; 2] = ["→", "->"]; + +impl Default for Glyphs { + fn default() -> Self { + Self::fitting(|_| true) + } +} + +impl Glyphs { + pub fn fitting(covers: impl Fn(char) -> bool) -> Self { + let symbol = |candidates: &[char]| { + candidates + .iter() + .copied() + .find(|candidate| covers(*candidate)) + .unwrap_or(candidates[candidates.len() - 1]) + }; + let text = |candidates: &[&'static str]| { + candidates + .iter() + .copied() + .find(|candidate| candidate.chars().all(&covers)) + .unwrap_or(candidates[candidates.len() - 1]) + }; + Self { + done: symbol(&DONE), + failed: symbol(&FAILED), + bead: symbol(&BEAD), + waiting_bead: symbol(&WAITING_BEAD), + still_going: symbol(&STILL_GOING), + running_mark: symbol(&RUNNING_MARK), + root_switch_mark: symbol(&ROOT_SWITCH_MARK), + ellipsis: text(&ELLIPSIS), + chain_link: text(&CHAIN_LINK), + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + const LAT2_TERMINUS16: &str = "×■●▶·•…│├└─━█▒░↑↓←→≥"; + const DEFAULT8X16: &str = "√■○►▶·•│├└─▌▐█▓▒░▀▄↑↓←→≥"; + + fn covered_by(font: &'static str) -> impl Fn(char) -> bool { + move |symbol| symbol.is_ascii() || font.contains(symbol) + } + + #[test] + fn a_font_without_the_square_root_and_pointer_falls_back() { + let glyphs = Glyphs::fitting(covered_by(LAT2_TERMINUS16)); + assert_eq!(glyphs.done, '+'); + assert_eq!(glyphs.running_mark, '▶'); + assert_eq!(glyphs.failed, '×'); + assert_eq!(glyphs.ellipsis, "…"); + } + + #[test] + fn the_built_in_kernel_font_loses_the_cross_and_ellipsis() { + let glyphs = Glyphs::fitting(covered_by(DEFAULT8X16)); + assert_eq!(glyphs.done, '√'); + assert_eq!(glyphs.failed, 'x'); + assert_eq!(glyphs.ellipsis, "..."); + assert_eq!(glyphs.chain_link, "→"); + } + + #[test] + fn full_unicode_keeps_every_preferred_glyph() { + let glyphs = Glyphs::default(); + assert_eq!((glyphs.done, glyphs.running_mark), ('√', '►')); + } +} diff --git a/src/lib.rs b/src/lib.rs index 0c725ff..b023062 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,3 +1,4 @@ +pub mod glyphs; pub mod model; pub mod palette; pub mod view; diff --git a/src/model.rs b/src/model.rs index b2a590a..bafd069 100644 --- a/src/model.rs +++ b/src/model.rs @@ -1,6 +1,8 @@ use std::{ collections::{HashMap, HashSet}, + iter::{self, Peekable}, time::Duration, + vec::IntoIter, }; #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -171,6 +173,7 @@ pub struct PendingRow { pub status: RowStatus, pub queued_at: Duration, pub running_since: Option, + pub chain: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] @@ -437,11 +440,17 @@ impl BootState { ..Tally::default() }; self.units.values().fold(carried, |mut tally, record| { - match (record.job, record.running_since(), record.outcome) { - (Some(_), Some(_), _) => tally.running += 1, - (Some(_), None, _) => tally.waiting += 1, - (None, _, Some(Outcome::Succeeded { .. } | Outcome::Abandoned)) => tally.done += 1, - _ => {} + if record.job.is_some() { + if record.running_since().is_some() { + tally.running += 1; + } else { + tally.waiting += 1; + } + } else if matches!( + record.outcome, + Some(Outcome::Succeeded { .. } | Outcome::Abandoned) + ) { + tally.done += 1; } tally }) @@ -581,6 +590,7 @@ impl BootState { }, queued_at: job.queued_at, running_since, + chain: Vec::new(), }); let candidates: Vec<&str> = self .waits_for(unit, pending) @@ -709,6 +719,78 @@ pub fn paths_to_running(rows: Vec) -> Vec { relink_siblings(survivors) } +const MIN_FOLDED_LINKS: usize = 2; + +struct TreeNode { + row: PendingRow, + children: Vec, +} + +impl TreeNode { + fn is_chain_link(&self) -> bool { + self.row.status == RowStatus::Waiting && self.children.len() == 1 + } + + fn foldable_links(&self) -> usize { + let mut links = 0; + let mut cursor = self; + while cursor.is_chain_link() && cursor.children[0].is_chain_link() { + links += 1; + cursor = &cursor.children[0]; + } + links + } + + fn fold(mut self, may_absorb: bool) -> Self { + let links = if may_absorb { self.foldable_links() } else { 0 }; + if links >= MIN_FOLDED_LINKS { + let (chain, below) = (0..links).fold( + (Vec::new(), self.children), + |(mut chain, mut children), _| { + let only = children.remove(0); + chain.push(only.row.label); + (chain, only.children) + }, + ); + self.row.chain = chain; + self.children = below; + } + self.children = self + .children + .into_iter() + .map(|child| child.fold(true)) + .collect(); + self + } + + fn flatten_into(self, depth: usize, rows: &mut Vec) { + rows.push(PendingRow { depth, ..self.row }); + self.children + .into_iter() + .for_each(|child| child.flatten_into(depth + 1, rows)); + } +} + +fn grow_forest(rows: &mut Peekable>, depth: usize) -> Vec { + iter::from_fn(|| { + let row = rows.next_if(|row| row.depth == depth)?; + Some(TreeNode { + row, + children: grow_forest(rows, depth + 1), + }) + }) + .collect() +} + +#[must_use] +pub fn fold_chains(rows: Vec) -> Vec { + let mut flattened = Vec::new(); + grow_forest(&mut rows.into_iter().peekable(), 0) + .into_iter() + .for_each(|root| root.fold(false).flatten_into(0, &mut flattened)); + relink_siblings(flattened) +} + fn relink_siblings(rows: Vec) -> Vec { let mut later_sibling: Vec = Vec::new(); let mut is_last: Vec = rows @@ -751,6 +833,8 @@ fn display_label(facts: &UnitFacts) -> String { #[cfg(test)] mod tests { + use std::iter::once; + use super::*; const MS: Duration = Duration::from_millis(1); @@ -855,6 +939,86 @@ mod tests { assert_eq!(lasts, [true, true, false, true, true]); } + fn chain_state(waits: &[(&str, &[&str])], running: &str) -> BootState { + let mut state = BootState::new(Phase::Host); + state.set_root(waits[0].0.to_owned()); + waits.iter().zip(1..).for_each(|((name, after), id)| { + let activity = if *name == running { + activating(Duration::ZERO) + } else { + Activity::default() + }; + state.track_unit(facts(name, after), activity); + state.queue_job(id, name, JobKind::BringsUp, Duration::ZERO); + }); + state + } + + fn folded_outline(state: &BootState) -> Vec { + fold_chains(paths_to_running(state.pending_rows())) + .into_iter() + .map(|row| { + let chain = once(row.label.as_str()) + .chain(row.chain.iter().map(String::as_str)) + .collect::>() + .join(" > "); + format!("{}{chain}", " ".repeat(row.depth)) + }) + .collect() + } + + #[test] + fn single_child_waiting_chains_fold_into_one_row() { + let state = chain_state( + &[ + ("root.target", &["a.service"]), + ("a.service", &["b.target"]), + ("b.target", &["c.service"]), + ("c.service", &["d.service"]), + ("d.service", &[]), + ], + "d.service", + ); + assert_eq!( + folded_outline(&state), + ["root.target", " a > b.target > c", " d"] + ); + } + + #[test] + fn branches_and_short_chains_stay_unfolded() { + let state = chain_state( + &[ + ("root.target", &["a.service"]), + ("a.service", &["b.service", "c.service"]), + ("b.service", &["d.service"]), + ("c.service", &[]), + ("d.service", &[]), + ], + "d.service", + ); + let mut both = chain_state( + &[ + ("root.target", &["a.service"]), + ("a.service", &["b.service", "c.service"]), + ("b.service", &[]), + ("c.service", &[]), + ], + "b.service", + ); + both.update_activity("c.service", activating(Duration::ZERO)); + assert_eq!( + folded_outline(&state), + ["root.target", " a", " b", " d"] + ); + let rows = fold_chains(paths_to_running(both.pending_rows())); + let lasts: Vec = rows + .iter() + .map(|row| *row.is_last_sibling.last().unwrap()) + .collect(); + assert_eq!(lasts, [true, true, false, true]); + } + #[test] fn with_nothing_running_only_the_root_target_stays_in_view() { let mut state = BootState::new(Phase::Host); diff --git a/src/run.rs b/src/run.rs index 4260673..fa83262 100644 --- a/src/run.rs +++ b/src/run.rs @@ -9,6 +9,7 @@ use std::{ }; use bootvine::{ + glyphs::Glyphs, model::{BootState, Phase}, palette::Palette, view::BootView, @@ -24,7 +25,7 @@ use signal_hook::{consts::SIGTERM, flag}; use crate::{ clock::monotonic_now, - console::{ForegroundVt, QuietKernelConsole}, + console::{ForegroundVt, QuietKernelConsole, font_characters}, error::Error, feed::Feed, sysroot::INITRD_RELEASE, @@ -66,6 +67,9 @@ pub fn run(options: &Options) -> Result<(), Error> { .then(QuietKernelConsole::take) .flatten(); let _foreground = ForegroundVt::take(); + let glyphs = font_characters().map_or_else(Glyphs::default, |characters| { + Glyphs::fitting(|symbol| symbol.is_ascii() || characters.contains(&symbol)) + }); let mut terminal = ratatui::try_init()?; let watched = watch( &mut state, @@ -73,6 +77,7 @@ pub fn run(options: &Options) -> Result<(), Error> { &mut terminal, &terminate, &options.palette, + &glyphs, options.hold, ); ratatui::restore(); @@ -111,6 +116,7 @@ fn watch( terminal: &mut DefaultTerminal, terminate: &AtomicBool, palette: &Palette, + glyphs: &Glyphs, hold: Duration, ) -> Result<(), Error> { let host = uname().nodename().to_string_lossy().into_owned(); @@ -126,6 +132,7 @@ fn watch( BootView { state, palette, + glyphs, now: monotonic_now(), host: &host, frame, diff --git a/src/systemd.rs b/src/systemd.rs index 7eebbc4..470921b 100644 --- a/src/systemd.rs +++ b/src/systemd.rs @@ -273,12 +273,20 @@ fn parse_signal(message: &Message) -> Option { } let interface = message.interface()?; let member = message.member()?; - match (&*interface, &*member) { - (MANAGER_INTERFACE, "JobNew") => { + match &*interface { + MANAGER_INTERFACE => parse_job_signal(message, &member), + PROPERTIES_INTERFACE if &*member == "PropertiesChanged" => parse_unit_change(message), + _ => None, + } +} + +fn parse_job_signal(message: &Message, member: &str) -> Option { + match member { + "JobNew" => { let (id, job, unit): (u32, Path<'static>, String) = message.read3().ok()?; Some(Signal::JobNew { id, job, unit }) } - (MANAGER_INTERFACE, "JobRemoved") => { + "JobRemoved" => { let (id, _job, _unit, result): (u32, Path<'static>, String, String) = message.read4().ok()?; Some(Signal::JobRemoved { @@ -286,21 +294,22 @@ fn parse_signal(message: &Message) -> Option { result: JobResult::parse(&result), }) } - (PROPERTIES_INTERFACE, "PropertiesChanged") => { - let (changed_interface, changed, _invalidated): (String, PropMap, Vec) = - message.read3().ok()?; - if changed_interface != UNIT_INTERFACE { - return None; - } - Some(Signal::UnitChanged { - path: message.path()?.into_static(), - activity: activity_from(&changed), - }) - } _ => None, } } +fn parse_unit_change(message: &Message) -> Option { + let (changed_interface, changed, _invalidated): (String, PropMap, Vec) = + message.read3().ok()?; + if changed_interface != UNIT_INTERFACE { + return None; + } + Some(Signal::UnitChanged { + path: message.path()?.into_static(), + activity: activity_from(&changed), + }) +} + fn activity_from(properties: &PropMap) -> Activity { let monotonic = |property: &str| { properties diff --git a/src/view.rs b/src/view.rs index e38481f..f93fcf4 100644 --- a/src/view.rs +++ b/src/view.rs @@ -1,165 +1,168 @@ -use std::{ - cmp::Reverse, - iter::{once, repeat_n}, - time::Duration, -}; +mod failures; +mod footer; +mod header; +mod stages; +mod timeline; +mod tree; + +use std::time::Duration; use jiff::fmt::friendly::{Designator, FractionalUnit, Spacing, SpanPrinter}; use ratatui::{ buffer::Buffer, layout::{Constraint, Layout, Rect}, - style::{Style, Stylize}, - text::{Line, Span}, - widgets::{Block, Borders, Paragraph, Row, Table, Widget}, + text::Line, + widgets::{Block, Borders, Widget}, }; +use self::{ + failures::Failures, footer::Footer, header::Header, stages::Stages, timeline::Timeline, + tree::PendingTree, +}; use crate::{ - model::{BootState, FinishedRun, MilestoneRow, PendingRow, RowStatus, Tally, paths_to_running}, + glyphs::Glyphs, + model::{BootState, PendingRow, RowStatus, fold_chains, paths_to_running}, palette::Palette, }; -const SPINNER: [char; 4] = ['|', '/', '-', '\\']; -const DONE: char = '√'; -const FAILED: char = '×'; -const BEAD: char = '■'; -const WAITING_BEAD: char = '·'; -const STILL_GOING: char = '▶'; -const RUNNING_MARK: char = '►'; -const ROOT_SWITCH_MARK: char = '│'; -const RULE: char = '─'; const RULE_STUB: &str = "──"; -const KERNEL_ORIGIN_LABEL: &str = "kernel"; -const SHUTDOWN_SUCCESSOR: &str = "systemd-shutdown"; - const DURATION_WIDTH: u16 = 8; -const TIMELINE_LABEL_WIDTH: u16 = 28; const MIN_BAR_WIDTH: u16 = 12; const MIN_HEIGHT_FOR_TIMELINE: u16 = 12; -const TIMELINE_CHROME_HEIGHT: u16 = 3; -const MIN_TIMELINE_HEIGHT: u16 = TIMELINE_CHROME_HEIGHT + 4; +const MIN_TIMELINE_HEIGHT: u16 = timeline::CHROME_HEIGHT + 4; +const NOTEWORTHY_DURATION: Duration = Duration::from_secs(1); const HEADER_HEIGHT: u16 = 2; -const FOOTER_HEIGHT: u16 = 2; -const MAX_FAILED_ROWS: usize = 3; -const AXIS_LABEL_SPACING: u16 = 8; -const AXIS_STEPS: [Duration; 12] = [ - Duration::from_secs(1), - Duration::from_secs(2), - Duration::from_secs(5), - Duration::from_secs(10), - Duration::from_secs(15), - Duration::from_secs(30), - Duration::from_mins(1), - Duration::from_mins(2), - Duration::from_mins(5), - Duration::from_mins(10), - Duration::from_mins(30), - Duration::from_hours(1), -]; const ELAPSED: SpanPrinter = SpanPrinter::new() .designator(Designator::Compact) .spacing(Spacing::None) .fractional(Some(FractionalUnit::Second)) .precision(Some(1)); -const AXIS_LABEL: SpanPrinter = SpanPrinter::new() - .designator(Designator::Compact) - .spacing(Spacing::None); pub struct BootView<'a> { pub state: &'a BootState, pub palette: &'a Palette, + pub glyphs: &'a Glyphs, pub now: Duration, pub host: &'a str, pub frame: u64, } -struct TimelineContent<'a> { - milestones: Vec, - finished: Vec<&'a FinishedRun>, - running: Vec<&'a PendingRow>, +impl BootView<'_> { + fn timeline<'a>(&'a self, rows: &'a [PendingRow]) -> Timeline<'a> { + let mut running: Vec<&PendingRow> = rows + .iter() + .filter(|row| !row.is_target && row.status == RowStatus::Running) + .collect(); + running.sort_by_key(|row| row.running_since); + Timeline { + origin: self.state.origin, + now: self.now, + root_switches: self + .state + .finished_stages + .iter() + .map(|stage| stage.reached_at) + .collect(), + milestones: self + .state + .milestones() + .into_iter() + .filter(|row| row.reached_at.is_some()) + .collect(), + finished: self + .state + .finished_runs + .iter() + .filter(|run| run.finished_at.saturating_sub(run.started_at) >= NOTEWORTHY_DURATION) + .collect(), + running, + palette: self.palette, + glyphs: self.glyphs, + } + } } impl Widget for BootView<'_> { fn render(self, area: Rect, buf: &mut Buffer) { let all_rows = self.state.pending_rows(); let pending_count = all_rows.len(); - let rows = paths_to_running(all_rows); - let folded = pending_count - rows.len(); - let mut running: Vec<&PendingRow> = rows - .iter() - .filter(|row| !row.is_target && row.status == RowStatus::Running) - .collect(); - running.sort_by_key(|row| row.running_since); - let milestones: Vec = self - .state - .milestones() - .into_iter() - .filter(|row| row.reached_at.is_some()) - .collect(); - let failures = self.failure_lines(); - let stages = self.stage_lines(area.width); - let stages_height = u16::try_from(stages.len()).unwrap_or(u16::MAX); - let failures_height = u16::try_from(failures.len()).unwrap_or(u16::MAX); - let fits_timeline = area.width >= TIMELINE_LABEL_WIDTH + 1 + MIN_BAR_WIDTH - && area.height >= MIN_HEIGHT_FOR_TIMELINE; - let timeline_entries = milestones.len() + self.state.finished_runs.len() + running.len(); - let timeline_need = if fits_timeline && timeline_entries > 0 { - TIMELINE_CHROME_HEIGHT - .saturating_add(u16::try_from(timeline_entries).unwrap_or(u16::MAX)) - } else { - 0 + let rows = fold_chains(paths_to_running(all_rows)); + let shown_units: usize = rows.iter().map(|row| 1 + row.chain.len()).sum(); + let header = Header { + host: self.host, + total: (!self.state.finished_stages.is_empty()) + .then(|| self.now.saturating_sub(self.state.origin)), + palette: self.palette, }; + let stages = Stages { + state: self.state, + now: self.now, + palette: self.palette, + glyphs: self.glyphs, + }; + let tree = PendingTree { + rows: &rows, + folded: pending_count - shown_units, + now: self.now, + frame: self.frame, + palette: self.palette, + glyphs: self.glyphs, + }; + let failures = Failures { + units: &self.state.failed, + palette: self.palette, + glyphs: self.glyphs, + }; + let timeline = self.timeline(&rows); + let footer = Footer { + tally: self.state.tally(), + shows_root_switch: !self.state.finished_stages.is_empty(), + palette: self.palette, + glyphs: self.glyphs, + }; + let fits_timeline = area.width >= timeline::LABEL_WIDTH + 1 + MIN_BAR_WIDTH + && area.height >= MIN_HEIGHT_FOR_TIMELINE; let heights = Heights::share( - area.height - .saturating_sub(HEADER_HEIGHT + stages_height + failures_height + FOOTER_HEIGHT), - u16::try_from(rows.len() + usize::from(folded > 0)).unwrap_or(u16::MAX), - timeline_need, + area.height.saturating_sub( + HEADER_HEIGHT + stages.height() + failures.height() + footer::HEIGHT, + ), + tree.height(), + if fits_timeline { timeline.height() } else { 0 }, ); - let [header, _, stage_area, tree, failed, _, timeline, footer] = Layout::vertical([ + let [ + header_area, + _, + stage_area, + tree_area, + failed_area, + _, + timeline_area, + footer_area, + ] = Layout::vertical([ Constraint::Length(1), Constraint::Length(HEADER_HEIGHT - 1), - Constraint::Length(stages_height), + Constraint::Length(stages.height()), Constraint::Length(heights.tree), - Constraint::Length(failures_height), + Constraint::Length(failures.height()), Constraint::Fill(1), Constraint::Length(heights.timeline), - Constraint::Length(FOOTER_HEIGHT), + Constraint::Length(footer::HEIGHT), ]) .areas(area); - self.header().render(header, buf); - Paragraph::new(stages).render(stage_area, buf); - self.tree(&rows, folded, tree.height).render(tree, buf); - Paragraph::new(failures).render(failed, buf); + header.render(header_area, buf); + stages.render(stage_area, buf); + tree.render(tree_area, buf); + failures.render(failed_area, buf); if heights.timeline > 0 { - let bar_rows = usize::from(heights.timeline.saturating_sub(TIMELINE_CHROME_HEIGHT)); - let finished_room = bar_rows.saturating_sub(milestones.len() + running.len()); - let mut finished: Vec<&FinishedRun> = self.state.finished_runs.iter().collect(); - finished.sort_by_key(|run| Reverse(run.finished_at.saturating_sub(run.started_at))); - finished.truncate(finished_room); - finished.sort_by_key(|run| run.started_at); - self.timeline( - &TimelineContent { - milestones, - finished, - running, - }, - timeline.width, - ) - .render(timeline, buf); + timeline.render(timeline_area, buf); } - self.footer(self.state.tally(), footer.width) - .render(footer, buf); + footer.render(footer_area, buf); } } -struct Conclusion<'a> { - finished: &'static str, - took: Duration, - handed_to: &'a str, -} - struct Heights { tree: u16, timeline: u16, @@ -183,547 +186,11 @@ impl Heights { } } -impl BootView<'_> { - fn rule_line( - &self, - width: u16, - left: Vec>, - right: Vec>, - ) -> Line<'static> { - let used = Line::from(left.clone()).width() + Line::from(right.clone()).width(); - let fill: String = repeat_n(RULE, usize::from(width).saturating_sub(used)).collect(); - Line::from( - left.into_iter() - .chain(once(Span::styled( - fill, - Style::new().fg(self.palette.muted), - ))) - .chain(right) - .collect::>(), - ) - } - - fn header(&self) -> Table<'static> { - let total = (!self.state.finished_stages.is_empty()).then(|| { - ELAPSED.unsigned_duration_to_string(&self.now.saturating_sub(self.state.origin)) - }); - Table::new( - [Row::new([ - Line::from(format!("bootvine {}", self.host)), - Line::from(total.unwrap_or_default()).right_aligned(), - ])], - [Constraint::Fill(1), Constraint::Length(DURATION_WIDTH)], - ) - .style(Style::new().fg(self.palette.text)) - .bold() - } - - fn stage_lines(&self, width: u16) -> Vec> { - let finished = self.state.finished_stages.iter().map(|stage| { - self.rule_line( - width, - vec![ - Span::styled( - format!("{RULE_STUB} {} {RULE_STUB} ", stage.label), - Style::new().fg(self.palette.muted), - ), - Span::styled( - format!( - "{BEAD} done in {}", - ELAPSED.unsigned_duration_to_string( - &stage.reached_at.saturating_sub(stage.started_at) - ) - ), - Style::new().fg(self.palette.done), - ), - Span::styled( - format!(" · {} ", unit_count(stage.finished_units)), - Style::new().fg(self.palette.waiting), - ), - ], - Vec::new(), - ) - }); - let current_started_at = self - .state - .finished_stages - .last() - .map_or(self.state.origin, |stage| stage.reached_at); - let conclusion = match self.state.manager_exited_at { - Some(exited_at) => Some(Conclusion { - finished: "shutdown", - took: exited_at.saturating_sub(self.state.origin), - handed_to: SHUTDOWN_SUCCESSOR, - }), - None => self.state.is_complete().then(|| Conclusion { - finished: "boot", - took: self.now.saturating_sub(self.state.origin), - handed_to: self - .state - .handoff_unit - .as_deref() - .or(self.state.root.as_deref()) - .unwrap_or("the console"), - }), - }; - let current = if let Some(conclusion) = conclusion { - self.rule_line( - width, - vec![ - Span::styled(format!("{RULE_STUB} "), Style::new().fg(self.palette.muted)), - Span::styled( - format!( - "{BEAD} {} finished in {}", - conclusion.finished, - ELAPSED.unsigned_duration_to_string(&conclusion.took) - ), - Style::new().fg(self.palette.done).bold(), - ), - Span::styled( - format!(" · handing over to {} ", conclusion.handed_to), - Style::new().fg(self.palette.text), - ), - ], - Vec::new(), - ) - } else { - self.rule_line( - width, - vec![ - Span::styled(format!("{RULE_STUB} "), Style::new().fg(self.palette.muted)), - Span::styled( - self.state.phase.label(), - Style::new().fg(self.palette.text).bold(), - ), - Span::raw(" "), - ], - vec![ - Span::raw(" "), - Span::styled( - ELAPSED.unsigned_duration_to_string( - &self.now.saturating_sub(current_started_at), - ), - Style::new().fg(self.palette.text).bold(), - ), - Span::styled(format!(" {RULE_STUB}"), Style::new().fg(self.palette.muted)), - ], - ) - }; - finished.chain(once(current)).collect() - } - - fn failure_lines(&self) -> Vec> { - let units = &self.state.failed; - let hidden = units.len().saturating_sub(MAX_FAILED_ROWS); - units - .iter() - .take(MAX_FAILED_ROWS) - .map(|unit| format!("{FAILED} {unit} failed")) - .chain((hidden > 0).then(|| format!("{FAILED} {hidden} more failed"))) - .map(|text| Line::styled(text, Style::new().fg(self.palette.failed).bold())) - .collect() - } - - fn label_style(&self, row: &PendingRow) -> Style { - match (row.is_target, row.status) { - (true, _) => Style::new().fg(self.palette.target), - (false, RowStatus::Running) => Style::new().fg(self.palette.text), - (false, RowStatus::Waiting) => Style::new().fg(self.palette.waiting), - } - } - - fn status_marker(&self, row: &PendingRow) -> Span<'static> { - match (row.is_target, row.status) { - (true, _) => Span::raw(""), - (false, RowStatus::Running) => { - let spinner = SPINNER[usize::try_from(self.frame % 4).unwrap_or_default()]; - Span::styled( - format!("[{spinner}] "), - Style::new().fg(self.palette.running), - ) - } - (false, RowStatus::Waiting) => { - Span::styled("[ ] ", Style::new().fg(self.palette.waiting)) - } - } - } - - fn tree<'a>(&self, rows: &'a [PendingRow], folded: usize, height: u16) -> Table<'a> { - let capacity = usize::from(height); - let shown = if rows.len() + usize::from(folded > 0) > capacity { - capacity.saturating_sub(1).min(rows.len()) - } else { - rows.len() - }; - let hidden = rows.len() - shown + folded; - let overflow = (hidden > 0).then(|| { - Row::new([Line::styled( - format!("… {hidden} more"), - Style::new().fg(self.palette.waiting), - )]) - }); - Table::new( - rows.iter() - .take(shown) - .map(|row| self.tree_row(row)) - .chain(overflow), - [Constraint::Fill(1), Constraint::Length(DURATION_WIDTH)], - ) - } - - fn tree_row<'a>(&self, row: &'a PendingRow) -> Row<'a> { - let since = row.running_since.unwrap_or(row.queued_at); - Row::new([ - Line::from(vec![ - Span::styled(tree_prefix(row), Style::new().fg(self.palette.muted)), - self.status_marker(row), - Span::styled(row.label.as_str(), self.label_style(row)), - ]), - Line::from(ELAPSED.unsigned_duration_to_string(&self.now.saturating_sub(since))) - .style(self.label_style(row)) - .right_aligned(), - ]) - } - - fn timeline<'a>(&self, content: &TimelineContent<'a>, width: u16) -> Table<'a> { - let axis = TimeAxis::new( - self.state.origin, - self.now, - width.saturating_sub(TIMELINE_LABEL_WIDTH + 1), - ); - let root_switches: Vec = self - .state - .finished_stages - .iter() - .map(|stage| stage.reached_at) - .collect(); - let muted = Style::new().fg(self.palette.muted); - let axis_rows = [ - Row::new([Line::default(), axis.labels(muted)]), - Row::new([Line::default(), axis.ticks_line(&root_switches, muted)]), - ]; - let entries = content - .milestones - .iter() - .map(|row| self.milestone_entry(row)) - .chain(content.finished.iter().map(|run| self.finished_entry(run))) - .chain(content.running.iter().map(|row| self.running_entry(row))); - let bar_rows = entries.map(|entry| { - Row::new([ - entry.label, - axis.bar(&entry.segments, entry.still_going_at, &root_switches, muted), - ]) - }); - Table::new( - axis_rows.into_iter().chain(bar_rows), - [ - Constraint::Length(TIMELINE_LABEL_WIDTH), - Constraint::Fill(1), - ], - ) - .block( - Block::new() - .borders(Borders::TOP) - .border_style(Style::new().fg(self.palette.muted)) - .title(Line::styled( - " timeline ", - Style::new().fg(self.palette.waiting), - )), - ) - } - - fn milestone_entry(&self, row: &MilestoneRow) -> TimelineEntry<'static> { - let done = Style::new().fg(self.palette.done); - TimelineEntry { - label: Line::styled( - format!("{DONE} {} ({})", row.label, unit_count(row.finished_units)), - done, - ), - segments: row - .reached_at - .map(|reached_at| Segment { - from: row.started_at, - to: reached_at, - symbol: BEAD, - style: done, - }) - .into_iter() - .collect(), - still_going_at: None, - } - } - - fn finished_entry<'a>(&self, run: &'a FinishedRun) -> TimelineEntry<'a> { - let (mark, outcome) = if run.failed { - (FAILED, Style::new().fg(self.palette.failed)) - } else { - (DONE, Style::new().fg(self.palette.done)) - }; - TimelineEntry { - label: Line::from(vec![ - Span::styled(format!("{mark} "), outcome), - Span::styled(run.label.as_str(), Style::new().fg(self.palette.waiting)), - ]), - segments: vec![Segment { - from: run.started_at, - to: run.finished_at, - symbol: BEAD, - style: outcome, - }], - still_going_at: None, - } - } - - fn running_entry<'a>(&self, row: &'a PendingRow) -> TimelineEntry<'a> { - let since = row.running_since.unwrap_or(row.queued_at); - let waited = (since > row.queued_at).then(|| Segment { - from: row.queued_at, - to: since, - symbol: WAITING_BEAD, - style: Style::new().fg(self.palette.waiting), - }); - let ran = Segment { - from: since, - to: self.now, - symbol: BEAD, - style: Style::new().fg(self.palette.running), - }; - TimelineEntry { - label: Line::from(vec![ - Span::styled( - format!("{RUNNING_MARK} "), - Style::new().fg(self.palette.running), - ), - Span::styled(row.label.as_str(), Style::new().fg(self.palette.text)), - ]), - segments: waited.into_iter().chain(once(ran)).collect(), - still_going_at: Some(self.now), - } - } - - fn footer(&self, tally: Tally, width: u16) -> Paragraph<'static> { - let failed_style = if tally.failed > 0 { - Style::new().fg(self.palette.failed).bold() - } else { - Style::new().fg(self.palette.waiting) - }; - let counts = vec![ - Span::styled( - format!("{DONE} {} done", tally.done), - Style::new().fg(self.palette.done), - ), - Span::styled( - format!(" {} running", tally.running), - Style::new().fg(self.palette.running), - ), - Span::styled( - format!(" {} waiting", tally.waiting), - Style::new().fg(self.palette.waiting), - ), - Span::styled(format!(" {FAILED} {} failed", tally.failed), failed_style), - ]; - let switch_legend = if self.state.finished_stages.is_empty() { - String::new() - } else { - format!(" {ROOT_SWITCH_MARK} root switch") - }; - let legend = format!("{BEAD} running {WAITING_BEAD} waiting{switch_legend}"); - let used = Line::from(counts.clone()).width() + legend.chars().count(); - let gap = usize::from(width).saturating_sub(used); - let spans = if gap >= 2 { - counts - .into_iter() - .chain([ - Span::raw(" ".repeat(gap)), - Span::styled(legend, Style::new().fg(self.palette.waiting)), - ]) - .collect() - } else { - counts - }; - Paragraph::new(Line::from(spans)).block( - Block::new() - .borders(Borders::TOP) - .border_style(Style::new().fg(self.palette.muted)), - ) - } -} - -struct TimelineEntry<'a> { - label: Line<'a>, - segments: Vec, - still_going_at: Option, -} - -struct Segment { - from: Duration, - to: Duration, - symbol: char, - style: Style, -} - -struct Stroke { - column: u16, - glyphs: String, - style: Style, -} - -impl Stroke { - fn run(column: u16, length: u16, symbol: char, style: Style) -> Self { - Self { - column, - glyphs: repeat_n(symbol, usize::from(length)).collect(), - style, - } - } -} - -#[derive(Clone, Copy, PartialEq)] -struct Glyph { - symbol: char, - style: Style, -} - -const BLANK: Glyph = Glyph { - symbol: ' ', - style: Style::new(), -}; - -fn canvas_line(width: u16, strokes: impl IntoIterator) -> Line<'static> { - let cells = strokes - .into_iter() - .fold(vec![BLANK; usize::from(width)], |mut cells, stroke| { - cells - .iter_mut() - .skip(usize::from(stroke.column)) - .zip(stroke.glyphs.chars()) - .for_each(|(cell, symbol)| { - *cell = Glyph { - symbol, - style: stroke.style, - }; - }); - cells - }); - Line::from( - cells - .chunk_by(|left, right| left.style == right.style) - .map(|run| { - Span::styled( - run.iter().map(|glyph| glyph.symbol).collect::(), - run[0].style, - ) - }) - .collect::>(), - ) -} - -struct TimeAxis { - origin: Duration, - span: Duration, - step: Duration, - width: u16, -} - -impl TimeAxis { - fn new(origin: Duration, now: Duration, width: u16) -> Self { - let elapsed = now.saturating_sub(origin).max(AXIS_STEPS[0]); - let max_labels = u128::from((width / AXIS_LABEL_SPACING).max(1)); - let step = AXIS_STEPS - .into_iter() - .find(|step| elapsed.as_nanos().div_ceil(step.as_nanos()) <= max_labels) - .unwrap_or(AXIS_STEPS[AXIS_STEPS.len() - 1]); - let steps = u32::try_from(elapsed.as_nanos().div_ceil(step.as_nanos())).unwrap_or(u32::MAX); - Self { - origin, - span: step * steps.max(1), - step, - width, - } - } - - fn column(&self, at: Duration) -> u16 { - let offset = at.saturating_sub(self.origin).min(self.span); - let column = offset.as_nanos() * u128::from(self.width) / self.span.as_nanos(); - u16::try_from(column) - .unwrap_or(u16::MAX) - .min(self.width.saturating_sub(1)) - } - - fn tick_offsets(&self) -> impl Iterator + '_ { - (0..) - .map(|index: u32| self.step * index) - .take_while(|offset| *offset <= self.span) - } - - fn labels(&self, style: Style) -> Line<'static> { - canvas_line( - self.width, - self.tick_offsets().map(|offset| { - let glyphs = if offset.is_zero() && self.origin.is_zero() { - KERNEL_ORIGIN_LABEL.to_owned() - } else { - AXIS_LABEL.unsigned_duration_to_string(&offset) - }; - let label_width = u16::try_from(glyphs.len()).unwrap_or(self.width); - Stroke { - column: self - .column(self.origin + offset) - .min(self.width.saturating_sub(label_width)), - glyphs, - style, - } - }), - ) - } - - fn ticks_line(&self, root_switches: &[Duration], style: Style) -> Line<'static> { - canvas_line( - self.width, - root_switches - .iter() - .map(|at| Stroke::run(self.column(*at), 1, ROOT_SWITCH_MARK, style)) - .chain( - self.tick_offsets().map(|offset| { - Stroke::run(self.column(self.origin + offset), 1, '|', style) - }), - ), - ) - } - - fn bar( - &self, - segments: &[Segment], - still_going_at: Option, - root_switches: &[Duration], - switch_style: Style, - ) -> Line<'static> { - let switches = root_switches - .iter() - .map(|at| Stroke::run(self.column(*at), 1, ROOT_SWITCH_MARK, switch_style)); - let bars = segments.iter().map(|segment| { - let start = self.column(segment.from); - let end = self.column(segment.to).max(start + 1); - Stroke::run(start, end - start, segment.symbol, segment.style) - }); - let still_going = - still_going_at.map(|now| Stroke::run(self.column(now), 1, STILL_GOING, switch_style)); - canvas_line(self.width, switches.chain(bars).chain(still_going)) - } -} - -fn tree_prefix(row: &PendingRow) -> String { - let ancestors = row - .is_last_sibling - .iter() - .skip(1) - .take(row.depth.saturating_sub(1)) - .map(|ancestor_is_last| if *ancestor_is_last { " " } else { "│ " }); - let connector = (row.depth > 0).then(|| match row.is_last_sibling.last() { - Some(false) => "├─ ", - _ => "└─ ", - }); - ancestors.chain(connector).chain(once("")).collect() +fn rule(palette: &Palette, left: Line<'static>) -> Block<'static> { + Block::new() + .borders(Borders::TOP) + .border_style(palette.muted) + .title(left) } fn unit_count(count: usize) -> String { @@ -759,6 +226,7 @@ mod tests { BootView { state, palette: &Palette::default(), + glyphs: &Glyphs::default(), now, host: "ryzen", frame: 1, @@ -875,6 +343,78 @@ mod tests { ); } + #[test] + fn only_running_units_carry_a_timer() { + let lines = render(&boot_in_progress(), 12_400 * MS, 110, 24); + let screen = lines.join("\n"); + assert!( + lines[3].trim_end().ends_with("graphical.target"), + "{screen}" + ); + assert!(lines[5].ends_with("6.4s"), "{screen}"); + } + + #[test] + fn sub_second_runs_stay_off_the_timeline() { + let mut state = boot_in_progress(); + state.track_unit(facts("blink.service", &[]), running_since(4000 * MS)); + state.queue_job(20, "blink.service", JobKind::BringsUp, 4000 * MS); + state.finish_job(20, JobResult::Done, 4400 * MS); + let lines = render(&state, 12_400 * MS, 110, 24); + assert!( + lines.iter().all(|line| !line.contains("blink")), + "{}", + lines.join("\n") + ); + } + + #[test] + fn folded_chains_shorten_to_their_ends_when_narrow() { + let mut state = BootState::new(Phase::Shutdown); + state.set_root("poweroff.target".to_owned()); + [ + ("poweroff.target", "systemd-poweroff.service"), + ("systemd-poweroff.service", "final.target"), + ("final.target", "shutdown.target"), + ("shutdown.target", "local-fs.target"), + ("local-fs.target", "demo-disk.service"), + ("demo-disk.service", "demo-db.service"), + ("demo-db.service", ""), + ] + .into_iter() + .zip(1..) + .for_each(|((name, waits_on), id)| { + let after: Vec<&str> = [waits_on].into_iter().filter(|w| !w.is_empty()).collect(); + let activity = if name == "demo-db.service" { + running_since(1000 * MS) + } else { + Activity::default() + }; + state.track_unit(facts(name, &after), activity); + state.queue_job(id, name, JobKind::BringsUp, Duration::ZERO); + }); + let wide = render(&state, 5000 * MS, 110, 24); + assert!( + wide[4].starts_with( + "└─ [ ] systemd-poweroff → final.target → shutdown.target → local-fs.target → \ + demo-disk" + ), + "{}", + wide.join("\n") + ); + assert!( + wide[5].starts_with(" └─ [/] demo-db"), + "{}", + wide.join("\n") + ); + let narrow = render(&state, 5000 * MS, 60, 24); + assert!( + narrow[4].starts_with("└─ [ ] systemd-poweroff → … → demo-disk"), + "{}", + narrow.join("\n") + ); + } + #[test] fn narrow_screens_drop_the_timeline() { let lines = render(&boot_in_progress(), 12_400 * MS, 36, 24); diff --git a/src/view/failures.rs b/src/view/failures.rs new file mode 100644 index 0000000..383acd3 --- /dev/null +++ b/src/view/failures.rs @@ -0,0 +1,40 @@ +use ratatui::{ + buffer::Buffer, + layout::Rect, + style::Stylize, + text::Line, + widgets::{Paragraph, Widget}, +}; + +use crate::{glyphs::Glyphs, palette::Palette}; + +const MAX_ROWS: usize = 3; + +pub struct Failures<'a> { + pub units: &'a [String], + pub palette: &'a Palette, + pub glyphs: &'a Glyphs, +} + +impl Failures<'_> { + pub fn height(&self) -> u16 { + u16::try_from(self.lines().len()).unwrap_or(u16::MAX) + } + + fn lines(&self) -> Vec> { + let hidden = self.units.len().saturating_sub(MAX_ROWS); + self.units + .iter() + .take(MAX_ROWS) + .map(|unit| format!("{} {unit} failed", self.glyphs.failed)) + .chain((hidden > 0).then(|| format!("{} {hidden} more failed", self.glyphs.failed))) + .map(|text| Line::from(text).fg(self.palette.failed).bold()) + .collect() + } +} + +impl Widget for Failures<'_> { + fn render(self, area: Rect, buf: &mut Buffer) { + Paragraph::new(self.lines()).render(area, buf); + } +} diff --git a/src/view/footer.rs b/src/view/footer.rs new file mode 100644 index 0000000..c4ac77b --- /dev/null +++ b/src/view/footer.rs @@ -0,0 +1,73 @@ +use ratatui::{ + buffer::Buffer, + layout::{Constraint, Rect}, + style::Stylize, + text::Line, + widgets::{Block, Borders, Row, Table, Widget}, +}; + +use crate::{glyphs::Glyphs, model::Tally, palette::Palette}; + +pub const HEIGHT: u16 = 2; +const LEGEND_GAP: usize = 2; + +pub struct Footer<'a> { + pub tally: Tally, + pub shows_root_switch: bool, + pub palette: &'a Palette, + pub glyphs: &'a Glyphs, +} + +impl Footer<'_> { + fn counts(&self) -> Line<'static> { + let failed = format!(" {} {} failed", self.glyphs.failed, self.tally.failed); + let failed = if self.tally.failed > 0 { + failed.fg(self.palette.failed).bold() + } else { + failed.fg(self.palette.waiting) + }; + Line::from(vec![ + format!("{} {} done", self.glyphs.done, self.tally.done).fg(self.palette.done), + format!(" {} running", self.tally.running).fg(self.palette.running), + format!(" {} waiting", self.tally.waiting).fg(self.palette.waiting), + failed, + ]) + } + + fn legend(&self) -> Line<'static> { + let root_switch = if self.shows_root_switch { + format!(" {} root switch", self.glyphs.root_switch_mark) + } else { + String::new() + }; + Line::from(format!( + "{} running {} waiting{root_switch}", + self.glyphs.bead, self.glyphs.waiting_bead + )) + .fg(self.palette.waiting) + .right_aligned() + } +} + +impl Widget for Footer<'_> { + fn render(self, area: Rect, buf: &mut Buffer) { + let counts = self.counts(); + let legend = self.legend(); + let legend_fits = counts.width() + legend.width() + LEGEND_GAP <= usize::from(area.width); + let legend_width = if legend_fits { + u16::try_from(legend.width()).unwrap_or(0) + } else { + 0 + }; + Table::new( + [Row::new([counts, legend])], + [Constraint::Fill(1), Constraint::Length(legend_width)], + ) + .block( + Block::new() + .borders(Borders::TOP) + .border_style(self.palette.muted), + ) + .render(area, buf); + } +} diff --git a/src/view/header.rs b/src/view/header.rs new file mode 100644 index 0000000..707ed90 --- /dev/null +++ b/src/view/header.rs @@ -0,0 +1,37 @@ +use std::time::Duration; + +use ratatui::{ + buffer::Buffer, + layout::{Constraint, Rect}, + style::Stylize, + text::Line, + widgets::{Row, Table, Widget}, +}; + +use super::{DURATION_WIDTH, ELAPSED}; +use crate::palette::Palette; + +pub struct Header<'a> { + pub host: &'a str, + pub total: Option, + pub palette: &'a Palette, +} + +impl Widget for Header<'_> { + fn render(self, area: Rect, buf: &mut Buffer) { + let total = self + .total + .map(|total| ELAPSED.unsigned_duration_to_string(&total)) + .unwrap_or_default(); + Table::new( + [Row::new([ + Line::from(format!("bootvine {}", self.host)), + Line::from(total).right_aligned(), + ])], + [Constraint::Fill(1), Constraint::Length(DURATION_WIDTH)], + ) + .fg(self.palette.text) + .bold() + .render(area, buf); + } +} diff --git a/src/view/stages.rs b/src/view/stages.rs new file mode 100644 index 0000000..1bdb02e --- /dev/null +++ b/src/view/stages.rs @@ -0,0 +1,128 @@ +use std::{iter::once, time::Duration}; + +use ratatui::{ + buffer::Buffer, + layout::Rect, + style::Stylize, + text::Line, + widgets::{Block, Widget}, +}; + +use super::{ELAPSED, RULE_STUB, rule, unit_count}; +use crate::{glyphs::Glyphs, model::BootState, palette::Palette}; + +const SHUTDOWN_SUCCESSOR: &str = "systemd-shutdown"; + +pub struct Stages<'a> { + pub state: &'a BootState, + pub now: Duration, + pub palette: &'a Palette, + pub glyphs: &'a Glyphs, +} + +struct Conclusion<'a> { + finished: &'static str, + took: Duration, + handed_to: &'a str, +} + +impl Stages<'_> { + pub fn height(&self) -> u16 { + u16::try_from(self.state.finished_stages.len() + 1).unwrap_or(u16::MAX) + } + + fn conclusion(&self) -> Option> { + if let Some(exited_at) = self.state.manager_exited_at { + return Some(Conclusion { + finished: "shutdown", + took: exited_at.saturating_sub(self.state.origin), + handed_to: SHUTDOWN_SUCCESSOR, + }); + } + self.state.is_complete().then(|| Conclusion { + finished: "boot", + took: self.now.saturating_sub(self.state.origin), + handed_to: self + .state + .handoff_unit + .as_deref() + .or(self.state.root.as_deref()) + .unwrap_or("the console"), + }) + } + + fn finished_rules(&self) -> impl Iterator> + '_ { + self.state.finished_stages.iter().map(|stage| { + rule( + self.palette, + Line::from(vec![ + format!("{RULE_STUB} {} {RULE_STUB} ", stage.label).fg(self.palette.muted), + format!( + "{} done in {}", + self.glyphs.bead, + ELAPSED.unsigned_duration_to_string( + &stage.reached_at.saturating_sub(stage.started_at) + ) + ) + .fg(self.palette.done), + format!(" · {} ", unit_count(stage.finished_units)).fg(self.palette.waiting), + ]), + ) + }) + } + + fn concluded_rule(&self, conclusion: &Conclusion) -> Block<'static> { + rule( + self.palette, + Line::from(vec![ + format!("{RULE_STUB} ").fg(self.palette.muted), + format!( + "{} {} finished in {}", + self.glyphs.bead, + conclusion.finished, + ELAPSED.unsigned_duration_to_string(&conclusion.took) + ) + .fg(self.palette.done) + .bold(), + format!(" · handing over to {} ", conclusion.handed_to).fg(self.palette.text), + ]), + ) + } + + fn current_rule(&self) -> Block<'static> { + let started_at = self + .state + .finished_stages + .last() + .map_or(self.state.origin, |stage| stage.reached_at); + let elapsed = ELAPSED.unsigned_duration_to_string(&self.now.saturating_sub(started_at)); + rule( + self.palette, + Line::from(vec![ + format!("{RULE_STUB} ").fg(self.palette.muted), + self.state.phase.label().fg(self.palette.text).bold(), + " ".into(), + ]), + ) + .title( + Line::from(vec![ + " ".into(), + elapsed.fg(self.palette.text).bold(), + format!(" {RULE_STUB}").fg(self.palette.muted), + ]) + .right_aligned(), + ) + } +} + +impl Widget for Stages<'_> { + fn render(self, area: Rect, buf: &mut Buffer) { + let last = self.conclusion().map_or_else( + || self.current_rule(), + |conclusion| self.concluded_rule(&conclusion), + ); + area.rows() + .zip(self.finished_rules().chain(once(last))) + .for_each(|(row, rule)| rule.render(row, buf)); + } +} diff --git a/src/view/timeline.rs b/src/view/timeline.rs new file mode 100644 index 0000000..a94baa2 --- /dev/null +++ b/src/view/timeline.rs @@ -0,0 +1,367 @@ +use std::{ + cmp::Reverse, + iter::{once, repeat_n}, + time::Duration, +}; + +use jiff::fmt::friendly::{Designator, Spacing, SpanPrinter}; +use ratatui::{ + buffer::Buffer, + layout::{Constraint, Rect}, + style::{Style, Stylize}, + text::{Line, Span}, + widgets::{Row, Table, Widget}, +}; + +use super::{rule, unit_count}; +use crate::{ + glyphs::Glyphs, + model::{FinishedRun, MilestoneRow, PendingRow}, + palette::Palette, +}; + +pub const LABEL_WIDTH: u16 = 28; +pub const CHROME_HEIGHT: u16 = 3; +const KERNEL_ORIGIN_LABEL: &str = "kernel"; +const AXIS_LABEL_SPACING: u16 = 8; +const AXIS_STEPS: [Duration; 12] = [ + Duration::from_secs(1), + Duration::from_secs(2), + Duration::from_secs(5), + Duration::from_secs(10), + Duration::from_secs(15), + Duration::from_secs(30), + Duration::from_mins(1), + Duration::from_mins(2), + Duration::from_mins(5), + Duration::from_mins(10), + Duration::from_mins(30), + Duration::from_hours(1), +]; +const AXIS_LABEL: SpanPrinter = SpanPrinter::new() + .designator(Designator::Compact) + .spacing(Spacing::None); + +pub struct Timeline<'a> { + pub origin: Duration, + pub now: Duration, + pub root_switches: Vec, + pub milestones: Vec, + pub finished: Vec<&'a FinishedRun>, + pub running: Vec<&'a PendingRow>, + pub palette: &'a Palette, + pub glyphs: &'a Glyphs, +} + +impl Timeline<'_> { + pub fn height(&self) -> u16 { + let entries = self.milestones.len() + self.finished.len() + self.running.len(); + if entries == 0 { + return 0; + } + CHROME_HEIGHT.saturating_add(u16::try_from(entries).unwrap_or(u16::MAX)) + } + + fn finished_that_fit(&self, height: u16) -> Vec<&FinishedRun> { + let bar_rows = usize::from(height.saturating_sub(CHROME_HEIGHT)); + let room = bar_rows.saturating_sub(self.milestones.len() + self.running.len()); + let mut longest_first = self.finished.clone(); + longest_first.sort_by_key(|run| Reverse(run.finished_at.saturating_sub(run.started_at))); + longest_first.truncate(room); + longest_first.sort_by_key(|run| run.started_at); + longest_first + } + + fn milestone_entry(&self, row: &MilestoneRow) -> TimelineEntry<'static> { + let done = Style::from(self.palette.done); + TimelineEntry { + label: Line::styled( + format!( + "{} {} ({})", + self.glyphs.done, + row.label, + unit_count(row.finished_units) + ), + done, + ), + segments: row + .reached_at + .map(|reached_at| Segment { + from: row.started_at, + to: reached_at, + symbol: self.glyphs.bead, + style: done, + }) + .into_iter() + .collect(), + still_going_at: None, + } + } + + fn finished_entry<'a>(&self, run: &'a FinishedRun) -> TimelineEntry<'a> { + let mark = if run.failed { + self.glyphs.failed + } else { + self.glyphs.done + }; + let outcome = Style::from(if run.failed { + self.palette.failed + } else { + self.palette.done + }); + TimelineEntry { + label: Line::from(vec![ + Span::styled(format!("{mark} "), outcome), + run.label.as_str().fg(self.palette.waiting), + ]), + segments: vec![Segment { + from: run.started_at, + to: run.finished_at, + symbol: self.glyphs.bead, + style: outcome, + }], + still_going_at: None, + } + } + + fn running_entry<'a>(&self, row: &'a PendingRow) -> TimelineEntry<'a> { + let since = row.running_since.unwrap_or(row.queued_at); + let waited = (since > row.queued_at).then(|| Segment { + from: row.queued_at, + to: since, + symbol: self.glyphs.waiting_bead, + style: self.palette.waiting.into(), + }); + let ran = Segment { + from: since, + to: self.now, + symbol: self.glyphs.bead, + style: self.palette.running.into(), + }; + TimelineEntry { + label: Line::from(vec![ + format!("{} ", self.glyphs.running_mark).fg(self.palette.running), + row.label.as_str().fg(self.palette.text), + ]), + segments: waited.into_iter().chain(once(ran)).collect(), + still_going_at: Some(self.now), + } + } +} + +impl Widget for Timeline<'_> { + fn render(self, area: Rect, buf: &mut Buffer) { + let axis = TimeAxis::new( + self.origin, + self.now, + area.width.saturating_sub(LABEL_WIDTH + 1), + *self.glyphs, + ); + let muted = Style::from(self.palette.muted); + let axis_rows = [ + Row::new([Line::default(), axis.labels(muted)]), + Row::new([Line::default(), axis.ticks_line(&self.root_switches, muted)]), + ]; + let entries: Vec = self + .milestones + .iter() + .map(|row| self.milestone_entry(row)) + .chain( + self.finished_that_fit(area.height) + .into_iter() + .map(|run| self.finished_entry(run)), + ) + .chain(self.running.iter().map(|row| self.running_entry(row))) + .collect(); + let bar_rows = entries.into_iter().map(|entry| { + Row::new([ + entry.label, + axis.bar( + &entry.segments, + entry.still_going_at, + &self.root_switches, + muted, + ), + ]) + }); + Table::new( + axis_rows.into_iter().chain(bar_rows), + [Constraint::Length(LABEL_WIDTH), Constraint::Fill(1)], + ) + .block(rule( + self.palette, + Line::from(" timeline ".fg(self.palette.waiting)), + )) + .render(area, buf); + } +} + +struct TimelineEntry<'a> { + label: Line<'a>, + segments: Vec, + still_going_at: Option, +} + +struct Segment { + from: Duration, + to: Duration, + symbol: char, + style: Style, +} + +struct Stroke { + column: u16, + glyphs: String, + style: Style, +} + +impl Stroke { + fn run(column: u16, length: u16, symbol: char, style: Style) -> Self { + Self { + column, + glyphs: repeat_n(symbol, usize::from(length)).collect(), + style, + } + } +} + +#[derive(Clone, Copy, PartialEq)] +struct Glyph { + symbol: char, + style: Style, +} + +const BLANK: Glyph = Glyph { + symbol: ' ', + style: Style::new(), +}; + +fn canvas_line(width: u16, strokes: impl IntoIterator) -> Line<'static> { + let cells = strokes + .into_iter() + .fold(vec![BLANK; usize::from(width)], |mut cells, stroke| { + cells + .iter_mut() + .skip(usize::from(stroke.column)) + .zip(stroke.glyphs.chars()) + .for_each(|(cell, symbol)| { + *cell = Glyph { + symbol, + style: stroke.style, + }; + }); + cells + }); + Line::from( + cells + .chunk_by(|left, right| left.style == right.style) + .map(|run| { + Span::styled( + run.iter().map(|glyph| glyph.symbol).collect::(), + run[0].style, + ) + }) + .collect::>(), + ) +} + +struct TimeAxis { + origin: Duration, + span: Duration, + step: Duration, + width: u16, + glyphs: Glyphs, +} + +impl TimeAxis { + fn new(origin: Duration, now: Duration, width: u16, glyphs: Glyphs) -> Self { + let elapsed = now.saturating_sub(origin).max(AXIS_STEPS[0]); + let max_labels = u128::from((width / AXIS_LABEL_SPACING).max(1)); + let step = AXIS_STEPS + .into_iter() + .find(|step| elapsed.as_nanos().div_ceil(step.as_nanos()) <= max_labels) + .unwrap_or(AXIS_STEPS[AXIS_STEPS.len() - 1]); + let steps = u32::try_from(elapsed.as_nanos().div_ceil(step.as_nanos())).unwrap_or(u32::MAX); + Self { + origin, + span: step * steps.max(1), + step, + width, + glyphs, + } + } + + fn column(&self, at: Duration) -> u16 { + let offset = at.saturating_sub(self.origin).min(self.span); + let column = offset.as_nanos() * u128::from(self.width) / self.span.as_nanos(); + u16::try_from(column) + .unwrap_or(u16::MAX) + .min(self.width.saturating_sub(1)) + } + + fn tick_offsets(&self) -> impl Iterator + '_ { + (0..) + .map(|index: u32| self.step * index) + .take_while(|offset| *offset <= self.span) + } + + fn labels(&self, style: Style) -> Line<'static> { + canvas_line( + self.width, + self.tick_offsets().map(|offset| { + let glyphs = if offset.is_zero() && self.origin.is_zero() { + KERNEL_ORIGIN_LABEL.to_owned() + } else { + AXIS_LABEL.unsigned_duration_to_string(&offset) + }; + let label_width = u16::try_from(glyphs.len()).unwrap_or(self.width); + Stroke { + column: self + .column(self.origin + offset) + .min(self.width.saturating_sub(label_width)), + glyphs, + style, + } + }), + ) + } + + fn ticks_line(&self, root_switches: &[Duration], style: Style) -> Line<'static> { + canvas_line( + self.width, + root_switches + .iter() + .map(|at| Stroke::run(self.column(*at), 1, self.glyphs.root_switch_mark, style)) + .chain( + self.tick_offsets().map(|offset| { + Stroke::run(self.column(self.origin + offset), 1, '|', style) + }), + ), + ) + } + + fn bar( + &self, + segments: &[Segment], + still_going_at: Option, + root_switches: &[Duration], + switch_style: Style, + ) -> Line<'static> { + let switches = root_switches.iter().map(|at| { + Stroke::run( + self.column(*at), + 1, + self.glyphs.root_switch_mark, + switch_style, + ) + }); + let bars = segments.iter().map(|segment| { + let start = self.column(segment.from); + let end = self.column(segment.to).max(start + 1); + Stroke::run(start, end - start, segment.symbol, segment.style) + }); + let still_going = still_going_at + .map(|now| Stroke::run(self.column(now), 1, self.glyphs.still_going, switch_style)); + canvas_line(self.width, switches.chain(bars).chain(still_going)) + } +} diff --git a/src/view/tree.rs b/src/view/tree.rs new file mode 100644 index 0000000..89c4a13 --- /dev/null +++ b/src/view/tree.rs @@ -0,0 +1,131 @@ +use std::{iter::once, time::Duration}; + +use ratatui::{ + buffer::Buffer, + layout::{Constraint, Rect}, + style::{Color, Stylize}, + text::{Line, Span}, + widgets::{Row, Table, Widget}, +}; + +use super::{DURATION_WIDTH, ELAPSED, NOTEWORTHY_DURATION}; +use crate::{ + glyphs::Glyphs, + model::{PendingRow, RowStatus}, + palette::Palette, +}; + +const SPINNER: [char; 4] = ['|', '/', '-', '\\']; + +pub struct PendingTree<'a> { + pub rows: &'a [PendingRow], + pub folded: usize, + pub now: Duration, + pub frame: u64, + pub palette: &'a Palette, + pub glyphs: &'a Glyphs, +} + +impl PendingTree<'_> { + pub fn height(&self) -> u16 { + u16::try_from(self.rows.len() + usize::from(self.folded > 0)).unwrap_or(u16::MAX) + } + + fn label_color(&self, row: &PendingRow) -> Color { + if row.is_target { + return self.palette.target; + } + match row.status { + RowStatus::Running => self.palette.text, + RowStatus::Waiting => self.palette.waiting, + } + } + + fn status_marker(&self, row: &PendingRow) -> Span<'static> { + if row.is_target { + return Span::default(); + } + match row.status { + RowStatus::Running => { + let spinner = SPINNER[usize::try_from(self.frame % 4).unwrap_or_default()]; + format!("[{spinner}] ").fg(self.palette.running) + } + RowStatus::Waiting => "[ ] ".fg(self.palette.waiting), + } + } + + fn chained_label(&self, row: &PendingRow, room: usize) -> String { + let link = format!(" {} ", self.glyphs.chain_link); + let Some(last) = row.chain.last() else { + return row.label.clone(); + }; + let full: String = once(row.label.as_str()) + .chain(row.chain.iter().map(String::as_str)) + .collect::>() + .join(&link); + if full.chars().count() <= room || row.chain.len() == 1 { + return full; + } + format!("{}{link}{}{link}{last}", row.label, self.glyphs.ellipsis) + } + + fn row(&self, row: &PendingRow, label_room: usize) -> Row<'static> { + let prefix = tree_prefix(row); + let marker = self.status_marker(row); + let room = label_room.saturating_sub(prefix.chars().count() + marker.width()); + let timer = row + .running_since + .map(|since| self.now.saturating_sub(since)) + .filter(|running_for| *running_for >= NOTEWORTHY_DURATION) + .map(|running_for| ELAPSED.unsigned_duration_to_string(&running_for)) + .unwrap_or_default(); + let color = self.label_color(row); + Row::new([ + Line::from(vec![ + prefix.fg(self.palette.muted), + marker, + self.chained_label(row, room).fg(color), + ]), + Line::from(timer).fg(color).right_aligned(), + ]) + } +} + +impl Widget for PendingTree<'_> { + fn render(self, area: Rect, buf: &mut Buffer) { + let capacity = usize::from(area.height); + let label_room = usize::from(area.width.saturating_sub(DURATION_WIDTH + 1)); + let shown = if usize::from(self.height()) > capacity { + capacity.saturating_sub(1).min(self.rows.len()) + } else { + self.rows.len() + }; + let hidden = self.rows.len() - shown + self.folded; + let overflow = (hidden > 0).then(|| { + Row::new([format!("{} {hidden} more", self.glyphs.ellipsis).fg(self.palette.waiting)]) + }); + Table::new( + self.rows + .iter() + .take(shown) + .map(|row| self.row(row, label_room)) + .chain(overflow), + [Constraint::Fill(1), Constraint::Length(DURATION_WIDTH)], + ) + .render(area, buf); + } +} + +fn tree_prefix(row: &PendingRow) -> String { + let ancestors = row + .is_last_sibling + .iter() + .skip(1) + .take(row.depth.saturating_sub(1)) + .map(|ancestor_is_last| if *ancestor_is_last { " " } else { "│ " }); + let connector = (row.depth > 0).then(|| match row.is_last_sibling.last() { + Some(false) => "├─ ", + _ => "└─ ", + }); + ancestors.chain(connector).chain(once("")).collect() +}