@@ -651,6 +651,198 @@ pub fn closure_edges_for_lock(lock: &StackLock, lock_file: &Path) -> HashMap<Str
651651 edges
652652}
653653
654+ /// Graphviz DOT for the dependency DAG of a solved lock.
655+ ///
656+ /// A node is `name/version` plus the toolchain, and the versionsuffix when
657+ /// the selected recipe has one. An edge points from a package to a
658+ /// dependency it selected. The label is the requirement as the solver read
659+ /// it, plus a versionsuffix or an explicit toolchain when the tuple carries
660+ /// one. A builddependency that is not also a runtime dependency is dashed.
661+ ///
662+ /// Edges come from the easyconfigs the lock names, the same walk as
663+ /// [`closure_edges_for_lock`]. A dependency the lock did not select is left
664+ /// out. Node order is the lock's package order made deterministic by name,
665+ /// version, versionsuffix, and toolchain.
666+ pub fn solved_dependency_dot ( lock : & StackLock , lock_file : & Path ) -> String {
667+ let lock_dir = lock_directory ( lock_file) ;
668+ let mut nodes: Vec < & crate :: domain:: LockPackage > = lock. packages . iter ( ) . collect ( ) ;
669+ nodes. sort_by ( |a, b| {
670+ (
671+ & a. name ,
672+ & a. version ,
673+ a. versionsuffix . as_deref ( ) . unwrap_or ( "" ) ,
674+ toolchain_text ( & a. toolchain ) ,
675+ )
676+ . cmp ( & (
677+ & b. name ,
678+ & b. version ,
679+ b. versionsuffix . as_deref ( ) . unwrap_or ( "" ) ,
680+ toolchain_text ( & b. toolchain ) ,
681+ ) )
682+ } ) ;
683+ let mut id_of: HashMap < String , String > = HashMap :: new ( ) ;
684+ for ( index, package) in nodes. iter ( ) . enumerate ( ) {
685+ id_of. insert ( package_identity ( package) , format ! ( "n{index}" ) ) ;
686+ }
687+
688+ let mut edges: BTreeMap < ( String , String ) , ( String , bool ) > = BTreeMap :: new ( ) ;
689+ for package in & lock. packages {
690+ let Some ( resolved) = ( !package. easyconfig_path . is_empty ( ) )
691+ . then ( || {
692+ crate :: eb_parse:: resolve_easyconfig_file ( & resolve_lock_easyconfig (
693+ lock_dir,
694+ & package. easyconfig_path ,
695+ ) )
696+ . ok ( )
697+ } )
698+ . flatten ( )
699+ else {
700+ continue ;
701+ } ;
702+ let candidate = resolved. to_candidate ( ) ;
703+ let from = package_identity ( package) ;
704+ for ( dep, runtime) in candidate
705+ . dependencies
706+ . iter ( )
707+ . map ( |dep| ( dep, true ) )
708+ . chain ( candidate. builddependencies . iter ( ) . map ( |dep| ( dep, false ) ) )
709+ {
710+ let Some ( target) = resolve_locked_dep ( lock, package, dep) else {
711+ continue ;
712+ } ;
713+ let key = ( from. clone ( ) , package_identity ( target) ) ;
714+ let label = dependency_edge_label ( dep) ;
715+ if let Some ( drawn) = edges. get_mut ( & key) {
716+ if runtime {
717+ * drawn = ( label, true ) ;
718+ }
719+ } else {
720+ edges. insert ( key, ( label, runtime) ) ;
721+ }
722+ }
723+ }
724+
725+ let mut out = String :: from ( "digraph solved {\n " ) ;
726+ out. push_str ( " rankdir=TB;\n " ) ;
727+ out. push_str ( " graph [fontname=\" Helvetica\" ];\n " ) ;
728+ out. push_str ( " node [shape=box, fontname=\" Helvetica\" , fontsize=11];\n " ) ;
729+ out. push_str ( " edge [fontname=\" Helvetica\" , fontsize=9];\n " ) ;
730+ for package in & nodes {
731+ let id = & id_of[ & package_identity ( package) ] ;
732+ let version = format ! (
733+ "{}{}" ,
734+ package. version,
735+ package. versionsuffix. as_deref( ) . unwrap_or( "" )
736+ ) ;
737+ // Graphviz `\n`, written as two characters so a node stays one source line.
738+ let label = format ! (
739+ "{}\\ n{}" ,
740+ dot_escape( & format!( "{}/{}" , package. name, version) ) ,
741+ dot_escape( & toolchain_text( & package. toolchain) )
742+ ) ;
743+ out. push_str ( & format ! ( " {id} [label=\" {label}\" ];\n " ) ) ;
744+ }
745+ for ( ( from, to) , ( label, runtime) ) in & edges {
746+ let Some ( from_id) = id_of. get ( from) else {
747+ continue ;
748+ } ;
749+ let Some ( to_id) = id_of. get ( to) else {
750+ continue ;
751+ } ;
752+ let style = if * runtime { "" } else { ", style=dashed" } ;
753+ out. push_str ( & format ! (
754+ " {from_id} -> {to_id} [label=\" {}\" , color=\" #004D40\" {style}];\n " ,
755+ dot_escape( label)
756+ ) ) ;
757+ }
758+ out. push_str ( "}\n " ) ;
759+ out
760+ }
761+
762+ /// Write the solved dependency DAG.
763+ ///
764+ /// `.svg` and `.png` are rendered with the Graphviz `dot` program. Any other
765+ /// suffix, including `.dot`, is the DOT source.
766+ pub fn write_solved_dependency_graph (
767+ lock : & StackLock ,
768+ lock_file : & Path ,
769+ out : & Path ,
770+ ) -> Result < ( ) , String > {
771+ let dot = solved_dependency_dot ( lock, lock_file) ;
772+ if let Some ( parent) = out. parent ( ) {
773+ if !parent. as_os_str ( ) . is_empty ( ) {
774+ std:: fs:: create_dir_all ( parent)
775+ . map_err ( |error| format ! ( "create {}: {error}" , parent. display( ) ) ) ?;
776+ }
777+ }
778+ let kind = out
779+ . extension ( )
780+ . and_then ( |ext| ext. to_str ( ) )
781+ . unwrap_or ( "" )
782+ . to_ascii_lowercase ( ) ;
783+ if kind == "svg" || kind == "png" {
784+ let mut child = std:: process:: Command :: new ( "dot" )
785+ . arg ( format ! ( "-T{kind}" ) )
786+ . arg ( "-o" )
787+ . arg ( out)
788+ . stdin ( std:: process:: Stdio :: piped ( ) )
789+ . spawn ( )
790+ . map_err ( |error| {
791+ format ! (
792+ "rendering {} needs the graphviz dot program: {error}" ,
793+ out. display( )
794+ )
795+ } ) ?;
796+ let stdin = child. stdin . as_mut ( ) . ok_or ( "dot stdin" ) ?;
797+ std:: io:: Write :: write_all ( stdin, dot. as_bytes ( ) )
798+ . map_err ( |error| format ! ( "write dot source: {error}" ) ) ?;
799+ // Drop stdin before waiting so dot sees EOF.
800+ child. stdin . take ( ) ;
801+ let status = child
802+ . wait ( )
803+ . map_err ( |error| format ! ( "wait for dot: {error}" ) ) ?;
804+ if !status. success ( ) {
805+ return Err ( format ! ( "dot exited {status}" ) ) ;
806+ }
807+ return Ok ( ( ) ) ;
808+ }
809+ std:: fs:: write ( out, dot) . map_err ( |error| format ! ( "write {}: {error}" , out. display( ) ) ) ?;
810+ Ok ( ( ) )
811+ }
812+
813+ fn toolchain_text ( toolchain : & crate :: domain:: Toolchain ) -> String {
814+ if crate :: hierarchy:: is_system_toolchain ( toolchain) {
815+ "system" . to_string ( )
816+ } else {
817+ format ! ( "{}-{}" , toolchain. name, toolchain. version)
818+ }
819+ }
820+
821+ fn dependency_edge_label ( dep : & crate :: domain:: DepReq ) -> String {
822+ let mut label = dep. version_req . clone ( ) ;
823+ if let Some ( suffix) = dep. versionsuffix . as_deref ( ) {
824+ if !suffix. is_empty ( ) {
825+ label. push_str ( " suffix " ) ;
826+ label. push_str ( suffix) ;
827+ }
828+ }
829+ if let Some ( toolchain) = & dep. toolchain {
830+ label. push_str ( " toolchain " ) ;
831+ if crate :: hierarchy:: is_system_toolchain ( toolchain) {
832+ label. push_str ( "system" ) ;
833+ } else {
834+ label. push_str ( & toolchain. name ) ;
835+ label. push ( '/' ) ;
836+ label. push_str ( & toolchain. version ) ;
837+ }
838+ }
839+ label
840+ }
841+
842+ fn dot_escape ( text : & str ) -> String {
843+ text. replace ( '\\' , "\\ \\ " ) . replace ( '"' , "\\ \" " )
844+ }
845+
654846/// How many recipes a lock SBOM could read.
655847#[ derive( Debug , Clone , Copy , PartialEq , Eq , Default ) ]
656848pub struct SbomReadStats {
0 commit comments