macports/mpbb
0
0
Fork 0
mirror of https://github.com/macports/mpbb.git synced 2026-07-12 18:18:44 -07:00
Code Issues Packages Projects Releases Wiki Activity

Use dict for portinfo, options, variations etc

Browse Source
This commit is contained in:
Joshua Root
2024-02-26 18:31:33 +11:00
parent b077d9129a
commit 4deeb43aa7
11 changed files with 305 additions and 322 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tools/archive-path.tcl
+5 -5
View File
@@ -30,10 +30,10 @@
# IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
proc split_variants {variants} {
set result {}
set result [dict create]
set l [regexp -all -inline -- {([-+])([[:alpha:]_]+[\w\.]*)} $variants]
foreach { match sign variant } $l {
lappend result $variant $sign
dict set result $variant $sign
}
return $result
}
@@ -59,9 +59,9 @@ if {[catch {set one_result [mportlookup $portname]}] || [llength $one_result] <
exit 0
}
array set portinfo [lindex $one_result 1]
if {[info exists portinfo(porturl)]} {
if {[catch {set mport [mportopen $portinfo(porturl) [list subport $portinfo(name)] $variations]}]} {
lassign $one_result portname portinfo
if {[dict exists $portinfo porturl]} {
if {[catch {set mport [mportopen [dict get $portinfo porturl] [dict create subport $portname] $variations]}]} {
ui_warn "failed to open port: $portname"
puts "nonexistent"
exit 0
tools/canonical-variants.tcl
+7 -7
View File
@@ -61,22 +61,22 @@ try {
}
# parse the given variants from the command line
array set variants {}
set variants [dict create]
foreach item [lrange $::argv 1 end] {
foreach {_ sign variant} [regexp -all -inline -- {([-+])([[:alpha:]_]+[\w\.]*)} $item] {
set variants($variant) $sign
dict set variants $variant $sign
}
}
# open the port to get its active variants
array set portinfo [lindex $result 1]
lassign $result portname portinfo
#try -pass_signal {...}
try {
set mport [mportopen $portinfo(porturl) [list subport $portname] [array get variants]]
set mport [mportopen [dict get $portinfo porturl] [dict create subport $portname] $variants]
} on error {eMessage} {
ui_error "mportopen ${portinfo(porturl)} failed: $eMessage"
ui_error "mportopen $portname from [dict get $portinfo porturl] failed: $eMessage"
exit 1
}
array set info [mportinfo $mport]
puts $info(canonical_active_variants)
set portinfo [mportinfo $mport]
puts [dict get $portinfo canonical_active_variants]
tools/dependencies.tcl
+81 -86
View File
@@ -94,26 +94,26 @@ try {
}
# parse the given variants from the command line
array set variants {}
set variants [dict create]
foreach item [lrange $::argv 1 end] {
foreach {_ sign variant} [regexp -all -inline -- {([-+])([[:alpha:]_]+[\w\.]*)} $item] {
set variants($variant) $sign
dict set variants $variant $sign
}
}
# open the port so we can run dependency calculation
array set portinfo [lindex $result 1]
lassign $result portname portinfo
#try -pass_signal {...}
try {
set mport [mportopen $portinfo(porturl) [list subport $portinfo(name)] [array get variants]]
set mport [mportopen [dict get $portinfo porturl] [dict create subport $portname] $variants]
} on error {eMessage} {
ui_error "mportopen ${portinfo(porturl)} failed: $eMessage"
ui_error "mportopen of $portname from [dict get $portinfo porturl] failed: $eMessage"
exit 2
}
array set portinfo [mportinfo $mport]
set portinfo [mportinfo $mport]
# Also checking for matching archive, in case supported_archs changed
if {[registry::entry imaged $portinfo(name) $portinfo(version) $portinfo(revision) $portinfo(canonical_active_variants)] ne ""
if {[registry::entry imaged $portname [dict get $portinfo version] [dict get $portinfo revision] [dict get $portinfo canonical_active_variants]] ne ""
&& [[ditem_key $mport workername] eval [list _archive_available]]} {
puts "$::argv already installed, not installing or activating dependencies"
exit 0
@@ -182,12 +182,11 @@ proc check_dep_needs_port {depspec retvar} {
}
# Get the ports needed by a given port.
proc collect_deps {portinfovar retvar} {
upvar $portinfovar portinfo
proc collect_deps {portinfo retvar} {
upvar $retvar ret
foreach deptype $::recursive_depstypes {
if {[info exists portinfo($deptype)]} {
foreach depspec $portinfo($deptype) {
if {[dict exists $portinfo $deptype]} {
foreach depspec [dict get $portinfo $deptype] {
check_dep_needs_port $depspec ret
}
}
@@ -207,13 +206,10 @@ proc get_maintainers {args} {
ui_error "mportlookup $portname failed: $eMessage"
continue
}
array unset portinfo
array set portinfo [lindex $result 1]
foreach sublist [macports::unobscure_maintainers $portinfo(maintainers)] {
foreach {key value} $sublist {
if {$key eq "email"} {
lappend retlist $value
}
set portinfo [lindex $result 1]
foreach maintainer [macports::unobscure_maintainers [dict get $portinfo maintainers]] {
if {[dict exists $maintainer email]} {
lappend retlist [dict get $maintainer email]
}
}
}
@@ -225,26 +221,26 @@ proc open_port {portname} {
set result [mportlookup $portname]
if {[llength $result] < 2} {
ui_error "No such port: $portname"
puts $::log_subports_progress "Building '$::portname' ... \[ERROR\] (unknown dependency '$portname') maintainers: [get_maintainers $::portname]."
puts $::log_subports_progress "Building '$::portname' ... \[FAIL\] (unknown dependency '$portname') maintainers: [get_maintainers $::portname]."
exit 1
}
} on error {eMessage} {
ui_error "mportlookup $portname failed: $eMessage"
exit 2
}
array set portinfo [lindex $result 1]
lassign $result portname portinfo
try {
set mport [mportopen $portinfo(porturl) [list subport $portinfo(name)] [list]]
set mport [mportopen [dict get $portinfo porturl] [dict create subport $portname] ""]
} on error {eMessage} {
ui_error "mportopen $portinfo(porturl) failed: $eMessage"
ui_error "mportopen $portname from [dict get $portinfo porturl] failed: $eMessage"
exit 2
}
if {![info exists ::mportinfo_array($mport)]} {
set ::mportinfo_array($mport) [mportinfo $mport]
set portinfo [mportinfo $mport]
if {![dict exists $::mportinfo_array $mport]} {
dict set ::mportinfo_array $mport $portinfo
}
array set portinfo $::mportinfo_array($mport)
return [list $mport [array get portinfo]]
return [list $mport $portinfo]
}
# Deactivate the given port, first deactivating any active dependents
@@ -256,41 +252,41 @@ proc deactivate_with_dependents {e} {
foreach dependent [$e dependents] {
deactivate_with_dependents $dependent
}
if {![registry::run_target $e deactivate [list ports_nodepcheck 1]]
&& [catch {portimage::deactivate [$e name] [$e version] [$e revision] [$e variants] [list ports_nodepcheck 1]} result]} {
set options [dict create ports_nodepcheck 1]
if {![registry::run_target $e deactivate $options]
&& [catch {portimage::deactivate [$e name] [$e version] [$e revision] [$e variants] $options} result]} {
puts stderr $::errorInfo
puts stderr "Deactivating [$e name] @[$e version]_[$e revision][$e variants] failed: $result"
exit 2
}
}
proc deactivate_unneeded {portinfovar} {
upvar $portinfovar portinfo
proc deactivate_unneeded {portinfo} {
# Unfortunately mportdepends doesn't have quite the right semantics
# to be useful here. It's concerned with what is needed and not
# present, whereas here we're concerned with removing what we can do
# without. Future API opportunity?
set deplist [list]
foreach deptype $::toplevel_depstypes {
if {[info exists portinfo($deptype)]} {
foreach depspec $portinfo($deptype) {
if {[dict exists $portinfo $deptype]} {
foreach depspec [dict get $portinfo $deptype] {
check_dep_needs_port $depspec deplist
}
}
}
set needed_array [dict create]
set mports_array [dict create]
while {$deplist ne ""} {
set dep [lindex $deplist end]
set deplist [lreplace ${deplist}[set deplist {}] end end]
if {![info exists needed_array($dep)]} {
set needed_array($dep) 1
if {![dict exists $needed_array $dep]} {
dict set needed_array $dep 1
set needed [list]
lassign [open_port $dep] mports_array($dep) infolist
array unset depportinfo
array set depportinfo $infolist
collect_deps depportinfo needed
lassign [open_port $dep] mport depportinfo
dict set mports_array $dep $mport
collect_deps $depportinfo needed
foreach newdep $needed {
if {![info exists needed_array($newdep)]} {
if {![dict exists $needed_array $newdep]} {
lappend deplist $newdep
}
}
@@ -305,16 +301,15 @@ proc deactivate_unneeded {portinfovar} {
# latter will reduce performance for universal installations a
# bit, but those are much less common and this ensures
# consistent behaviour.
if {![info exists needed_array([$e name])]} {
if {![dict exists $needed_array [$e name]]} {
deactivate_with_dependents $e
} else {
array unset entryinfo
array set entryinfo $::mportinfo_array($mports_array([$e name]))
if {$entryinfo(version) ne [$e version]
|| $entryinfo(revision) != [$e revision]
|| $entryinfo(canonical_active_variants) ne [$e variants]} {
set entryinfo [dict get $::mportinfo_array [dict get $mports_array [$e name]]]
if {[dict get $entryinfo version] ne [$e version]
|| [dict get $entryinfo revision] != [$e revision]
|| [dict get $entryinfo canonical_active_variants] ne [$e variants]} {
lappend dependents_check_list $e
puts stderr "[$e name] installed version @[$e version]_[$e revision][$e variants] doesn't match tree version $entryinfo(version)_$entryinfo(revision)$entryinfo(canonical_active_variants)"
puts stderr "[$e name] installed version @[$e version]_[$e revision][$e variants] doesn't match tree version [dict get $entryinfo version]_[dict get $entryinfo revision][dict get $entryinfo canonical_active_variants]"
}
}
}
@@ -329,14 +324,15 @@ proc deactivate_unneeded {portinfovar} {
# earlier - it most likely won't be used again (and will be
# reopened in the uncommon case that it is needed.)
foreach e [registry::entry installed] {
mportclose $mports_array([$e name])
mportclose [dict get $mports_array [$e name]]
}
}
puts stderr "init took [expr {[clock seconds] - $start_time}] seconds"
set start_time [clock seconds]
if {[catch {deactivate_unneeded portinfo} result]} {
set mportinfo_array [dict create]
if {[catch {deactivate_unneeded $portinfo} result]} {
ui_error $::errorInfo
ui_error "deactivate_unneeded failed: $result"
exit 2
@@ -360,7 +356,7 @@ if {[catch {mportdepends $mport "activate" 1 1 0 dlist} result]} {
proc append_it {ditem} {
lappend ::dlist_sorted $ditem
set ::mportinfo_array($ditem) [mportinfo $ditem]
dict set ::mportinfo_array $ditem [mportinfo $ditem]
return 0
}
try {
@@ -391,12 +387,12 @@ puts $log_status_dependencies ""
## ensure dependencies are installed and active
proc checkdep_failcache {ditem} {
array set depinfo $::mportinfo_array($ditem)
set depinfo [dict get $::mportinfo_array $ditem]
if {[check_failcache $depinfo(name) [ditem_key $ditem porturl] $depinfo(canonical_active_variants)]} {
tee "Dependency '$depinfo(name)' with variants '$depinfo(canonical_active_variants)' has previously failed and is required." $::log_status_dependencies stderr
puts "Port $depinfo(name) previously failed in build [check_failcache $depinfo(name) [ditem_key $ditem porturl] $depinfo(canonical_active_variants) yes]"
puts $::log_subports_progress "Building '$::portname' ... \[ERROR\] (failed to install dependency '$depinfo(name)') maintainers: [get_maintainers $::portname $depinfo(name)]."
if {[check_failcache [dict get $depinfo name] [ditem_key $ditem porturl] [dict get $depinfo canonical_active_variants]]} {
tee "Dependency '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]' has previously failed and is required." $::log_status_dependencies stderr
puts "Port [dict get $depinfo name] previously failed in build [check_failcache [dict get $depinfo name] [ditem_key $ditem porturl] [dict get $depinfo canonical_active_variants] yes]"
puts $::log_subports_progress "Building '$::portname' ... \[FAIL\] (failed to install dependency '[dict get $depinfo name]') maintainers: [get_maintainers $::portname [dict get $depinfo name]]."
# could keep going to report all deps in the failcache, but failing fast seems better
exit 1
}
@@ -426,12 +422,12 @@ proc clean_workdirs {} {
# Returns 0 if dep is installed, 1 if not
proc install_dep_archive {ditem} {
array set depinfo $::mportinfo_array($ditem)
set depinfo [dict get $::mportinfo_array $ditem]
incr ::dependencies_counter
set msg "Installing dependency ($::dependencies_counter of $::dependencies_count) '$depinfo(name)' with variants '$depinfo(canonical_active_variants)'"
set msg "Installing dependency ($::dependencies_counter of $::dependencies_count) '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]'"
puts -nonewline $::log_status_dependencies "$msg ... "
puts "----> ${msg}"
if {[registry::entry imaged $depinfo(name) $depinfo(version) $depinfo(revision) $depinfo(canonical_active_variants)] ne ""} {
if {[registry::entry imaged [dict get $depinfo name] [dict get $depinfo version] [dict get $depinfo revision] [dict get $depinfo canonical_active_variants]] ne ""} {
puts "Already installed, nothing to do"
puts $::log_status_dependencies {[OK]}
return 0
@@ -449,14 +445,14 @@ proc install_dep_archive {ditem} {
if {$fail || $result > 0 || [$workername eval [list find_portarchive_path]] eq ""} {
# The known_fail case should normally be caught before now, but
# it's quick and easy to check and may save a build.
if {[info exists depinfo(known_fail)] && [string is true -strict $depinfo(known_fail)]} {
puts stderr "Dependency '$depinfo(name)' with variants '$depinfo(canonical_active_variants)' is known to fail, aborting."
if {[dict exists $depinfo known_fail] && [string is true -strict [dict get $depinfo known_fail]]} {
puts stderr "Dependency '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]' is known to fail, aborting."
puts $::log_status_dependencies {[FAIL] (known_fail)}
puts $::log_subports_progress "Building '$::portname' ... \[ERROR\] (dependency '$depinfo(name)' known to fail) maintainers: [get_maintainers $::portname $depinfo(name)]."
puts $::log_subports_progress "Building '$::portname' ... \[FAIL\] (dependency '[dict get $depinfo name]' known to fail) maintainers: [get_maintainers $::portname [dict get $depinfo name]]."
exit 1
}
# This dep will have to be built, not just installed
puts stderr "Fetching archive for dependency '$depinfo(name)' with variants '$depinfo(canonical_active_variants)' failed."
puts stderr "Fetching archive for dependency '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]' failed."
puts $::log_status_dependencies {[MISSING]}
return 1
}
@@ -467,9 +463,9 @@ proc install_dep_archive {ditem} {
set fail 1
}
if {$fail || $result > 0} {
puts stderr "Installing from archive for dependency '$depinfo(name)' with variants '$depinfo(canonical_active_variants)' failed, aborting."
puts stderr "Installing from archive for dependency '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]' failed, aborting."
puts $::log_status_dependencies {[FAIL]}
puts $::log_subports_progress "Building '$::portname' ... \[ERROR\] (failed to install dependency '$depinfo(name)')."
puts $::log_subports_progress "Building '$::portname' ... \[FAIL\] (failed to install dependency '$depinfo(name)')."
exit 1
}
@@ -487,10 +483,9 @@ proc close_open_mports {} {
set macports::open_mports [list]
}
proc install_dep_source {portinfo_list} {
array set depinfo $portinfo_list
proc install_dep_source {depinfo} {
incr ::build_counter
set msg "Building dependency ($::build_counter of $::build_count) '$depinfo(name)' with variants '$depinfo(canonical_active_variants)'"
set msg "Building dependency ($::build_counter of $::build_count) '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]'"
puts -nonewline $::log_status_dependencies "$msg ... "
puts "----> ${msg}"
@@ -499,15 +494,15 @@ proc install_dep_source {portinfo_list} {
set macports::channels(info) {}
close_open_mports
clean_workdirs
array unset ::mportinfo_array
set ditem [lindex [open_port $depinfo(name)] 0]
set ::mportinfo_array [dict create]
set ditem [lindex [open_port [dict get $depinfo name]] 0]
# Ensure archivefetch is not attempted at all
set workername [ditem_key $ditem workername]
$workername eval [list set portutil::archive_available_result 0]
$workername eval [list archive_sites]
# deactivate ports not needed for this dep
if {[catch {deactivate_unneeded depinfo} result]} {
if {[catch {deactivate_unneeded $depinfo} result]} {
ui_error $::errorInfo
ui_error "deactivate_unneeded failed: $result"
exit 2
@@ -525,9 +520,9 @@ proc install_dep_source {portinfo_list} {
set fail 1
}
if {$fail || $result > 0} {
puts stderr "Fetch of dependency '$depinfo(name)' with variants '$depinfo(canonical_active_variants)' failed, aborting."
puts stderr "Fetch of dependency '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]' failed, aborting."
puts $::log_status_dependencies {[FAIL] (fetch)}
puts $::log_subports_progress "Building '$::portname' ... \[ERROR\] (failed to fetch dependency '$depinfo(name)') maintainers: [get_maintainers $::portname $depinfo(name)]."
puts $::log_subports_progress "Building '$::portname' ... \[FAIL\] (failed to fetch dependency '[dict get $depinfo name]') maintainers: [get_maintainers $::portname [dict get $depinfo name]]."
exit 1
}
if {[catch {mportexec $ditem checksum} result]} {
@@ -536,9 +531,9 @@ proc install_dep_source {portinfo_list} {
set fail 1
}
if {$fail || $result > 0} {
puts stderr "Checksum of dependency '$depinfo(name)' with variants '$depinfo(canonical_active_variants)' failed, aborting."
puts stderr "Checksum of dependency '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]' failed, aborting."
puts $::log_status_dependencies {[FAIL] (checksum)}
puts $::log_subports_progress "Building '$::portname' ... \[ERROR\] (failed to checksum dependency '$depinfo(name)') maintainers: [get_maintainers $::portname $depinfo(name)]."
puts $::log_subports_progress "Building '$::portname' ... \[FAIL\] (failed to checksum dependency '[dict get $depinfo name]') maintainers: [get_maintainers $::portname [dict get $depinfo name]]."
exit 1
}
@@ -549,12 +544,12 @@ proc install_dep_source {portinfo_list} {
set fail 1
}
if {$fail || $result > 0} {
puts stderr "Build of dependency '$depinfo(name)' with variants '$depinfo(canonical_active_variants)' failed, aborting."
puts stderr "Build of dependency '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]' failed, aborting."
puts $::log_status_dependencies {[FAIL]}
puts $::log_subports_progress "Building '$::portname' ... \[ERROR\] (failed to install dependency '$depinfo(name)') maintainers: [get_maintainers $::portname $depinfo(name)]."
puts $::log_subports_progress "Building '$::portname' ... \[FAIL\] (failed to install dependency '[dict get $depinfo name]') maintainers: [get_maintainers $::portname [dict get $depinfo name]]."
if {$::failcache_dir ne ""} {
failcache_update $depinfo(name) [ditem_key $ditem porturl] $depinfo(canonical_active_variants) 1
failcache_update [dict get $depinfo name] [ditem_key $ditem porturl] [dict get $depinfo canonical_active_variants] 1
}
ui_debug "Open mports:"
foreach mport $macports::open_mports {
@@ -565,7 +560,7 @@ proc install_dep_source {portinfo_list} {
# Success. Clear any failcache entry.
if {$::failcache_dir ne ""} {
failcache_update $depinfo(name) [ditem_key $ditem porturl] $depinfo(canonical_active_variants) 0
failcache_update [dict get $depinfo name] [ditem_key $ditem porturl] [dict get $depinfo canonical_active_variants] 0
}
puts $::log_status_dependencies {[OK]}
}
@@ -578,7 +573,7 @@ set missing_deps [list]
try {
foreach ditem $dlist_sorted {
if {[install_dep_archive $ditem]} {
lappend missing_deps $::mportinfo_array($ditem)
lappend missing_deps [dict get $::mportinfo_array $ditem]
}
}
} on error {eMessage} {
@@ -610,15 +605,15 @@ if {$build_count > 0} {
set macports::channels(debug) {}
set macports::channels(info) {}
close_open_mports
array unset ::mportinfo_array
set ::mportinfo_array [dict create]
try {
set mport [mportopen $portinfo(porturl) [list subport $portinfo(name)] [array get variants]]
set mport [mportopen [dict get $portinfo porturl] [dict create subport $portname] $variants]
} on error {eMessage} {
ui_error "mportopen $portinfo(porturl) failed: $eMessage"
ui_error "mportopen $portname from [dict get $portinfo porturl] failed: $eMessage"
exit 2
}
[ditem_key $mport workername] eval [list set portutil::archive_available_result 0]
if {[catch {deactivate_unneeded portinfo} result]} {
if {[catch {deactivate_unneeded $portinfo} result]} {
ui_error $::errorInfo
ui_error "deactivate_unneeded failed: $result"
exit 2
@@ -666,9 +661,9 @@ proc activate_dep {ditem} {
set fail 1
}
if {$fail || $result > 0} {
array set depinfo $::mportinfo_array($ditem)
puts stderr "Activation of dependency '$depinfo(name)' with variants '$depinfo(canonical_active_variants)' failed, aborting."
puts $::log_subports_progress "Building '$::portname' ... \[ERROR\] (failed to activate dependency '$depinfo(name)') maintainers: [get_maintainers $::portname $depinfo(name)]."
set depinfo [dict get $::mportinfo_array $ditem]
puts stderr "Activation of dependency '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]' failed, aborting."
puts $::log_subports_progress "Building '$::portname' ... \[FAIL\] (failed to activate dependency '[dict get $depinfo name]') maintainers: [get_maintainers $::portname [dict get $depinfo name]]."
exit 1
}
}
tools/failcache-cleanup.tcl
+2 -3
View File
@@ -33,9 +33,8 @@ if {$failcache_dir eq ""} {
file delete -force [file join $failcache_dir $f]
continue
}
array unset portinfo
array set portinfo [lindex $result 1]
set hash [port_files_checksum $portinfo(porturl)]
set portinfo [lindex $result 1]
set hash [port_files_checksum [dict get $portinfo porturl]]
if {$entry_hash ne $hash} {
puts "Removing stale failcache entry: $f"
file delete -force [file join $failcache_dir $f]
tools/gather-archives.tcl
+3 -4
View File
@@ -73,11 +73,10 @@ while {[gets $infd line] >= 0} {
continue
}
array unset portinfo
array set portinfo [lindex $result 1]
lassign $result portname portinfo
foreach e [registry::entry imaged $portinfo(name)] {
if {[$e version] ne $portinfo(version) || [$e revision] != $portinfo(revision)} {
foreach e [registry::entry imaged $portname] {
if {[$e version] ne [dict get $portinfo version] || [$e revision] != [dict get $portinfo revision]} {
puts "Skipping [$e name] @[$e version]_[$e revision][$e variants] (not current)"
continue
}
tools/mirror-multi.tcl
+44 -55
View File
@@ -58,13 +58,13 @@ foreach vers {20 21 22 23} {
}
set deptypes [list depends_fetch depends_extract depends_patch depends_build depends_lib depends_run depends_test]
array set processed [list]
array set mirror_done [list]
array set distfiles_results [list]
set processed [dict create]
set mirror_done [dict create]
set distfiles_results [dict create]
proc check_mirror_done {portname} {
if {[info exists ::mirror_done($portname)]} {
return $::mirror_done($portname)
if {[dict exists $::mirror_done $portname]} {
return [dict get $::mirror_done $portname]
}
set cache_entry [file join $::mirrorcache_dir [string toupper [string index $portname 0]] $portname]
if {[file isfile $cache_entry]} {
@@ -72,9 +72,8 @@ proc check_mirror_done {portname} {
if {[llength $result] < 2} {
return 0
}
array unset portinfo
array set portinfo [lindex $result 1]
set portfile [file join [macports::getportdir $portinfo(porturl)] Portfile]
set portinfo [lindex $result 1]
set portfile [file join [macports::getportdir [dict get $portinfo porturl]] Portfile]
if {[file isfile $portfile]} {
set portfile_hash [sha256 file $portfile]
set fd [open $cache_entry]
@@ -83,29 +82,28 @@ proc check_mirror_done {portname} {
close $fd
if {$portfile_hash eq $entry_hash} {
if {$partial eq ""} {
set ::mirror_done($portname) 1
dict set ::mirror_done $portname 1
return 1
} else {
set ::mirror_done($portname) $partial
dict set ::mirror_done $portname $partial
return $partial
}
} else {
file delete -force $cache_entry
set ::mirror_done($portname) 0
dict set ::mirror_done $portname 0
}
}
} else {
set ::mirror_done($portname) 0
dict set ::mirror_done $portname 0
}
return 0
}
proc set_mirror_done {portname value} {
if {![info exists ::mirror_done($portname)] || $::mirror_done($portname) != 1} {
if {![dict exists $::mirror_done $portname] || [dict get $::mirror_done $portname] != 1} {
set result [mportlookup $portname]
array unset portinfo
array set portinfo [lindex $result 1]
set portfile [file join [macports::getportdir $portinfo(porturl)] Portfile]
set portinfo [lindex $result 1]
set portfile [file join [macports::getportdir [dict get $portinfo porturl]] Portfile]
set portfile_hash [sha256 file $portfile]
set cache_dir [file join $::mirrorcache_dir [string toupper [string index $portname 0]]]
@@ -117,16 +115,15 @@ proc set_mirror_done {portname value} {
puts $fd $value
}
close $fd
set ::mirror_done($portname) 1
dict set ::mirror_done $portname 1
}
}
proc get_dep_list {portinfovar} {
upvar $portinfovar portinfo
set deps {}
proc get_dep_list {portinfo} {
set deps [list]
foreach deptype $::deptypes {
if {[info exists portinfo($deptype)]} {
foreach dep $portinfo($deptype) {
if {[dict exists $portinfo $deptype]} {
foreach dep [dict get $portinfo $deptype] {
lappend deps [lindex [split $dep :] end]
}
}
@@ -134,18 +131,14 @@ proc get_dep_list {portinfovar} {
return $deps
}
proc get_variants {portinfovar} {
upvar $portinfovar portinfo
if {![info exists portinfo(vinfo)]} {
proc get_variants {portinfo} {
if {![dict exists $portinfo vinfo]} {
return {}
}
set variants {}
array set vinfo $portinfo(vinfo)
foreach v [array names vinfo] {
array unset variant
array set variant $vinfo($v)
if {![info exists variant(is_default)] || $variant(is_default) ne "+"} {
lappend variants $v
dict for {vname variant} [dict get $portinfo vinfo] {
if {![dict exists $variant is_default] || [dict get $variant is_default] ne "+"} {
lappend variants $vname
}
}
return $variants
@@ -161,7 +154,7 @@ proc save_distfiles_results {mport succeeded} {
set distpath [_mportkey $mport distpath]
foreach distfile $all_dist_files {
set filepath [file join $distpath $distfile]
set ::distfiles_results($filepath) $succeeded
dict set ::distfiles_results $filepath $succeeded
}
}
@@ -201,9 +194,9 @@ proc skip_mirror {mport identifier} {
}
set distfile [getdistname $distfile]
set filepath [file join $distpath $distfile]
if {![info exists ::distfiles_results($filepath)]} {
if {![dict exists $::distfiles_results $filepath]} {
set any_unmirrored 1
} elseif {$::distfiles_results($filepath) == 0} {
} elseif {[dict get $::distfiles_results $filepath] == 0} {
ui_msg "Skipping ${identifier}: $distfile already failed checksum"
return 2
}
@@ -216,24 +209,22 @@ proc skip_mirror {mport identifier} {
}
proc mirror_port {portinfo_list} {
array set portinfo $portinfo_list
set portname $portinfo(name)
set porturl $portinfo(porturl)
set ::processed($portname) 1
proc mirror_port {portinfo} {
set portname [dict get $portinfo name]
set porturl [dict get $portinfo porturl]
dict set ::processed $portname 1
set do_mirror 1
set attempted 0
set succeeded 0
if {[lsearch -exact -nocase $portinfo(license) "nomirror"] >= 0} {
if {[lsearch -exact -nocase [dict get $portinfo license] "nomirror"] >= 0} {
ui_msg "Not mirroring $portname due to license"
set do_mirror 0
}
if {[catch {mportopen $porturl [list subport $portname] {}} mport]} {
if {[catch {mportopen $porturl [dict create subport $portname] {}} mport]} {
ui_error "mportopen $porturl failed: $mport"
return 1
}
array unset portinfo
array set portinfo [mportinfo $mport]
set portinfo [mportinfo $mport]
set skip_result [skip_mirror $mport $portname]
if {$do_mirror && $skip_result == 0} {
@@ -251,18 +242,17 @@ proc mirror_port {portinfo_list} {
}
mportclose $mport
set deps [get_dep_list portinfo]
set variants [get_variants portinfo]
set deps [get_dep_list $portinfo]
set variants [get_variants $portinfo]
foreach variant $variants {
ui_msg "$portname +${variant}"
if {[catch {mportopen $porturl [list subport $portname] [list $variant +]} mport]} {
if {[catch {mportopen $porturl [dict create subport $portname] [dict create $variant +]} mport]} {
ui_error "mportopen $porturl failed: $mport"
continue
}
array unset portinfo
array set portinfo [mportinfo $mport]
lappend deps {*}[get_dep_list portinfo]
set portinfo [mportinfo $mport]
lappend deps {*}[get_dep_list $portinfo]
set skip_result [skip_mirror $mport "$portname +${variant}"]
if {$do_mirror && $skip_result == 0} {
incr attempted
@@ -281,13 +271,12 @@ proc mirror_port {portinfo_list} {
foreach {os_major os_arch} $::platforms {
ui_msg "$portname with platform 'darwin $os_major $os_arch'"
if {[catch {mportopen $porturl [list subport $portname os_major $os_major os_arch $os_arch] {}} mport]} {
if {[catch {mportopen $porturl [dict create subport $portname os_major $os_major os_arch $os_arch] {}} mport]} {
ui_error "mportopen $porturl failed: $mport"
continue
}
array unset portinfo
array set portinfo [mportinfo $mport]
lappend deps {*}[get_dep_list portinfo]
set portinfo [mportinfo $mport]
lappend deps {*}[get_dep_list $portinfo]
set skip_result [skip_mirror $mport "$portname darwin $os_major $os_arch"]
if {$do_mirror && $skip_result == 0} {
incr attempted
@@ -306,7 +295,7 @@ proc mirror_port {portinfo_list} {
set dep_failed 0
foreach dep [lsort -unique $deps] {
if {![info exists ::processed($dep)] && [check_mirror_done $dep] == 0} {
if {![dict exists $::processed $dep] && [check_mirror_done $dep] == 0} {
set result [mportlookup $dep]
if {[llength $result] < 2} {
ui_error "No such port: $dep"
@@ -338,7 +327,7 @@ if {[lindex $::argv 0] eq "-c"} {
set exitval 0
foreach portname $::argv {
if {[info exists ::processed($portname)]} {
if {[dict exists $::processed $portname]} {
ui_msg "skipping ${portname}, already processed"
continue
}
tools/portgroups.tcl
+8 -8
View File
@@ -32,10 +32,10 @@
# IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
proc split_variants {variants} {
set result {}
set result [dict create]
set l [regexp -all -inline -- {([-+])([[:alpha:]_]+[\w\.]*)} $variants]
foreach { match sign variant } $l {
lappend result $variant $sign
dict set result $variant $sign
}
return $result
}
@@ -74,21 +74,21 @@ try {
}
# open the port so we can run dependency calculation
array set portinfo [lindex $result 1]
lassign $result portname portinfo
#try -pass_signal {...}
try {
set mport [mportopen $portinfo(porturl) [list subport $portname] $variations]
set mport [mportopen [dict get $portinfo porturl] [dict create subport $portname] $variations]
} on error {eMessage} {
ui_error "mportopen ${portinfo(porturl)} failed: $eMessage"
ui_error "mportopen for $portname with url [dict get $portinfo porturl] failed: $eMessage"
exit 1
}
# obtain PortInfo array for this port and print the list of included
# PortGroups
array set portinfo [mportinfo $mport]
set portinfo [mportinfo $mport]
# only ports that include at least one PortGroup have portinfo(portgroups) set
if {[info exists portinfo(portgroups)]} {
foreach portgroup $portinfo(portgroups) {
if {[dict exists $portinfo portgroups]} {
foreach portgroup [dict get $portinfo portgroups] {
lassign $portgroup group version
puts "$group-$version"
}
tools/reclaim-space.tcl
+9 -9
View File
@@ -19,18 +19,18 @@ package require Tclx
mportinit
random seed
array set candidates {}
set candidates [dict create]
fs-traverse -ignoreErrors -- f [list ${macports::portdbpath}/distfiles] {
if {[file type $f] eq "file"} {
# 0 for distfile, 1 for port
set candidates($f) 0
dict set candidates $f 0
}
}
foreach port [registry::entry imaged] {
if {[$port dependents] eq ""} {
set candidates($port) 1
dict set candidates $port 1
}
}
@@ -44,7 +44,7 @@ proc active_files_size {port} {
return $total
}
set candidate_list [array names candidates]
set candidate_list [dict keys $candidates]
# It is tempting to sort by size and delete the largest things first,
# but picking randomly greatly reduces the chance that we will just
# uninstall one huge port that will immediately be reinstalled as a
@@ -53,7 +53,7 @@ while {$cur_free < $target && [llength $candidate_list] > 0} {
set i [random [llength $candidate_list]]
set chosen [lindex $candidate_list $i]
set candidate_list [lreplace ${candidate_list}[set candidate_list {}] $i $i]
if {$candidates($chosen) == 0} {
if {[dict get $candidates $chosen] == 0} {
set size [file size $chosen]
incr cur_free $size
puts "Deleting $chosen ($size bytes)"
@@ -69,14 +69,14 @@ while {$cur_free < $target && [llength $candidate_list] > 0} {
set deps [$chosen dependencies]
puts "Uninstalling [$chosen name] @[$chosen version]_[$chosen revision][$chosen variants] ($size bytes)"
if {!$dryrun} {
if {![registry::run_target $chosen uninstall [list]]} {
if {![registry::run_target $chosen uninstall ""]} {
# Portfile failed, use the registry directly
registry_uninstall::uninstall [$chosen name] [$chosen version] [$chosen revision] [$chosen variants] [list]
registry_uninstall::uninstall [$chosen name] [$chosen version] [$chosen revision] [$chosen variants] ""
}
}
foreach dep $deps {
if {![info exists candidates($dep)] && [$dep dependents] eq ""} {
set candidates($dep) 1
if {![dict exists $candidates $dep] && [$dep dependents] eq ""} {
dict set candidates $dep 1
lappend candidate_list $dep
}
}
tools/sort-with-subports.tcl
+118 -116
View File
@@ -48,14 +48,14 @@ proc ui_channels {priority} {
proc process_port_deps {portname} {
set deplist $::portdepinfo($portname)
unset ::portdepinfo($portname)
if {[info exists ::portsoftdeps($portname)]} {
lappend deplist {*}$::portsoftdeps($portname)
unset ::portsoftdeps($portname)
set deplist [dict get $::portdepinfo $portname]
dict unset ::portdepinfo $portname
if {[dict exists $::portsoftdeps $portname]} {
lappend deplist {*}[dict get $::portsoftdeps $portname]
dict unset ::portsoftdeps $portname
}
foreach portdep $deplist {
if {[info exists ::portdepinfo($portdep)]} {
if {[dict exists $::portdepinfo $portdep]} {
process_port_deps $portdep
}
}
@@ -63,45 +63,45 @@ proc process_port_deps {portname} {
}
proc check_failing_deps {portname} {
if {[info exists ::failingports($portname)]} {
return $::failingports($portname)
if {[dict exists ::failingports $portname]} {
return [dict get $::failingports $portname]
}
# Protect against dependency cycles
set ::failingports($portname) [list 3 $portname]
foreach portdep $::portdepinfo($portname) {
dict set ::failingports $portname [list 3 $portname]
foreach portdep [dict get $::portdepinfo $portname] {
set dep_ret [check_failing_deps $portdep]
# 0 = ok, 1 = known_fail, 2 = failcache, 3 = dep cycle
set status [lindex $dep_ret 0]
if {$status != 0} {
set failed_dep [lindex $dep_ret 1]
if {$::outputports($portname) == 1} {
if {[dict get $::outputports $portname] == 1} {
if {$status == 1} {
if {[info exists ::requestedports($portname)]} {
puts stderr "Excluding $::canonicalnames($portname) because its dependency '$failed_dep' is known to fail"
if {[dict exists $::requestedports $portname]} {
puts stderr "Excluding [dict get $::canonicalnames $portname] because its dependency '$failed_dep' is known to fail"
}
set ::outputports($portname) 0
} elseif {$status == 2 && ![info exists ::requestedports($portname)]} {
dict set ::outputports $portname 0
} elseif {$status == 2 && ![dict exists $::requestedports $portname]} {
# Exclude deps that will fail due to their own dep being in the failcache.
# But still output requested ports so the failure will be reported.
set ::outputports($portname) 0
dict set ::outputports $portname 0
} elseif {$status == 3} {
if {[info exists ::requestedports($portname)]} {
puts stderr "Warning: $::canonicalnames($portname) appears to have a cyclic dependency involving '$portdep'"
if {[dict exists $::requestedports $portname]} {
puts stderr "Warning: [dict get $::canonicalnames $portname] appears to have a cyclic dependency involving '$portdep'"
}
# Some cycles involving depends_test exist, which don't cause
# problems yet only because we don't run tests.
#set ::outputports($portname) 0
#dict set ::outputports $portname 0
}
}
# keep processing other deps for now if there was a dep cycle
if {$status != 3} {
set ::failingports($portname) [list $status $failed_dep]
return $::failingports($portname)
dict set ::failingports $portname [list $status $failed_dep]
return [dict get $::failingports $portname]
}
}
}
set ::failingports($portname) [list 0 ""]
return $::failingports($portname)
dict set ::failingports $portname [list 0 ""]
return [dict get $::failingports $portname]
}
source [file join [file dirname [info script]] failcache.tcl]
@@ -158,9 +158,10 @@ if {$jobs_dir ne "" && $archive_site_public ne "" && $archive_site_private ne ""
set is_64bit_capable [sysctl hw.cpu64bit_capable]
array set portdepinfo {}
array set portsoftdeps {}
array set canonicalnames {}
set portdepinfo [dict create]
set portsoftdeps [dict create]
set canonicalnames [dict create]
set failingports [dict create]
set todo [list]
if {[lindex $argv 0] eq "-"} {
while {[gets stdin line] >= 0} {
@@ -172,10 +173,13 @@ if {[lindex $argv 0] eq "-"} {
}
}
# save the ones that the user actually wants to know about
set inputports [dict create]
set outputports [dict create]
set requestedports [dict create]
foreach p $todo {
set inputports($p) 1
set outputports($p) 1
set requestedports($p) 1
dict set inputports $p 1
dict set outputports $p 1
dict set requestedports $p 1
}
# process all recursive deps
set depstypes [list depends_fetch depends_extract depends_patch depends_build depends_lib depends_run]
@@ -183,87 +187,87 @@ while {[llength $todo] > 0} {
set p [lindex $todo 0]
set todo [lreplace ${todo}[set todo {}] 0 0]
if {![info exists portdepinfo($p)]} {
if {![dict exists $portdepinfo $p]} {
if {[catch {mportlookup $p} result]} {
puts stderr "$errorInfo"
error "Failed to find port '$p': $result"
}
if {[llength $result] < 2} {
puts stderr "port $p not found in the index"
set portdepinfo($p) [list]
set outputports($p) 0
dict set portdepinfo $p ""
dict set outputports $p 0
continue
}
array set portinfo [lindex $result 1]
set portinfo [lindex $result 1]
if {[info exists inputports($p)]} {
if {[dict exists $inputports $p]} {
if {$failcache_dir ne ""} {
failcache_clear_all $portinfo(name)
failcache_clear_all [dict get $portinfo name]
}
if {[info exists portinfo(subports)]} {
foreach subport $portinfo(subports) {
if {[dict exists $portinfo subports]} {
foreach subport [dict get $portinfo subports] {
set splower [string tolower $subport]
if {![info exists portdepinfo($splower)]} {
if {![dict exists $portdepinfo $splower]} {
lappend todo $splower
}
if {![info exists requestedports($splower)]} {
set outputports($splower) 1
set requestedports($splower) 1
if {![dict exists $requestedports $splower]} {
dict set outputports $splower 1
dict set requestedports $splower 1
}
}
}
}
set opened 0
if {$outputports($p) == 1} {
if {[info exists portinfo(replaced_by)]} {
if {[info exists requestedports($p)]} {
puts stderr "Excluding $portinfo(name) because it is replaced by $portinfo(replaced_by)"
if {[dict get $outputports $p] == 1} {
if {[dict exists $portinfo replaced_by]} {
if {[dict exists $requestedports $p]} {
puts stderr "Excluding [dict get $portinfo name] because it is replaced by [dict get $portinfo replaced_by]"
}
set outputports($p) 0
} elseif {[info exists portinfo(known_fail)] && [string is true -strict $portinfo(known_fail)]} {
if {[info exists requestedports($p)]} {
puts stderr "Excluding $portinfo(name) because it is known to fail"
dict set outputports $p 0
} elseif {[dict exists $portinfo known_fail] && [string is true -strict [dict get $portinfo known_fail]]} {
if {[dict exists $requestedports $p]} {
puts stderr "Excluding [dict get $portinfo name] because it is known to fail"
}
set outputports($p) 0
set failingports($p) [list 1 $portinfo(name)]
} elseif {$failcache_dir ne "" && ![info exists requestedports($p)]} {
dict set outputports $p 0
dict set failingports $p [list 1 [dict get $portinfo name]]
} elseif {$failcache_dir ne "" && ![dict exists $requestedports $p]} {
# exclude dependencies with a failcache entry
if {![catch {mportopen $portinfo(porturl) [list subport $portinfo(name)] ""} result]} {
if {![catch {mportopen [dict get $portinfo porturl] [dict create subport [dict get $portinfo name]] ""} result]} {
set opened 1
set mport $result
array set portinfo [mportinfo $mport]
if {![info exists portinfo(canonical_active_variants)]} {
puts stderr "Warning: $portinfo(name) has no canonical_active_variants"
set outputports($p) 0
} elseif {[check_failcache $portinfo(name) $portinfo(porturl) $portinfo(canonical_active_variants)] != 0} {
set outputports($p) 0
set failingports($p) [list 2 $portinfo(name)]
set portinfo [mportinfo $mport]
if {![dict exists $portinfo canonical_active_variants]} {
puts stderr "Warning: [dict get $portinfo name] has no canonical_active_variants"
dict set outputports $p 0
} elseif {[check_failcache [dict get $portinfo name] [dict get $portinfo porturl] [dict get $portinfo canonical_active_variants]] != 0} {
dict set outputports $p 0
dict set failingports $p [list 2 [dict get $portinfo name]]
}
} else {
set outputports($p) 0
dict set outputports $p 0
}
}
if {$archive_site_public ne "" && $outputports($p) == 1} {
if {$archive_site_public ne "" && [dict get $outputports $p] == 1} {
# FIXME: support non-default variants
if {$opened == 1 || ![catch {mportopen $portinfo(porturl) [list subport $portinfo(name)] ""} result]} {
if {$opened == 1 || ![catch {mportopen [dict get $portinfo porturl] [dict create subport [dict get $portinfo name]] ""} result]} {
if {$opened != 1} {
set opened 1
set mport $result
array set portinfo [mportinfo $mport]
set portinfo [mportinfo $mport]
}
set workername [ditem_key $mport workername]
set archive_name [$workername eval {get_portimage_name}]
set archive_name_encoded [portfetch::percent_encode $archive_name]
if {![catch {curl getsize ${archive_site_public}/$portinfo(name)/${archive_name_encoded}} size] && $size > 0} {
if {![catch {curl getsize ${archive_site_public}/[dict get $portinfo name]/${archive_name_encoded}} size] && $size > 0} {
# Check for other installed variants that might not have been uploaded
set archives_prefix ${macports::portdbpath}/software/$portinfo(name)/$portinfo(name)-$portinfo(version)_$portinfo(revision)
set archives_prefix ${macports::portdbpath}/software/[dict get $portinfo name]/[dict get $portinfo name]-[dict get $portinfo version]_[dict get $portinfo revision]
set any_archive_missing 0
foreach installed_archive [glob -nocomplain -tails -path ${archives_prefix} *] {
if {$installed_archive ne $archive_name} {
set installed_archive_encoded [portfetch::percent_encode $installed_archive]
if {[catch {curl getsize ${archive_site_public}/$portinfo(name)/${installed_archive_encoded}} size] || $size <= 0} {
if {[catch {curl getsize ${archive_site_public}/[dict get $portinfo name]/${installed_archive_encoded}} size] || $size <= 0} {
set any_archive_missing 1
puts stderr "$installed_archive installed but not uploaded"
break
@@ -271,75 +275,75 @@ while {[llength $todo] > 0} {
}
}
if {!$any_archive_missing} {
if {[info exists requestedports($p)]} {
puts stderr "Excluding $portinfo(name) because it has already been built and uploaded to the public server"
if {[dict exists $requestedports $p]} {
puts stderr "Excluding [dict get $portinfo name] because it has already been built and uploaded to the public server"
}
set outputports($p) 0
dict set outputports $p 0
}
}
} else {
if {[info exists requestedports($p)]} {
puts stderr "Excluding $portinfo(name) because it failed to open: $result"
if {[dict exists $requestedports $p]} {
puts stderr "Excluding [dict get $portinfo name] because it failed to open: $result"
}
set outputports($p) 0
dict set outputports $p 0
}
if {$outputports($p) == 1 && $archive_site_private ne "" && $jobs_dir ne ""} {
if {[dict get $outputports $p] == 1 && $archive_site_private ne "" && $jobs_dir ne ""} {
# FIXME: support non-default variants
set results [check_licenses $portinfo(name) [list]]
if {[lindex $results 0] == 1 && ![catch {curl getsize ${archive_site_private}/$portinfo(name)/${archive_name_encoded}} size] && $size > 0} {
if {[info exists requestedports($p)]} {
puts stderr "Excluding $portinfo(name) because it is not distributable and it has already been built and uploaded to the private server"
set results [check_licenses [dict get $portinfo name] [list]]
if {[lindex $results 0] == 1 && ![catch {curl getsize ${archive_site_private}/[dict get $portinfo name]/${archive_name_encoded}} size] && $size > 0} {
if {[dict exists $requestedports $p]} {
puts stderr "Excluding [dict get $portinfo name] because it is not distributable and it has already been built and uploaded to the private server"
}
set outputports($p) 0
dict set outputports $p 0
}
}
}
if {$outputports($p) == 1 &&
if {[dict get $outputports $p] == 1 &&
($::macports::os_major <= 10 || $::macports::os_major >= 18)} {
if {$opened == 1 || ![catch {mportopen $portinfo(porturl) [list subport $portinfo(name)] ""} result]} {
if {$opened == 1 || ![catch {mportopen [dict get $portinfo porturl] [dict create subport [dict get $portinfo name]] ""} result]} {
if {$opened != 1} {
set opened 1
set mport $result
array set portinfo [mportinfo $mport]
set portinfo [mportinfo $mport]
}
set supported_archs [_mportkey $mport supported_archs]
switch $::macports::os_arch {
arm {
if {$supported_archs ne "" && $supported_archs ne "noarch" && "arm64" ni $supported_archs} {
if {[info exists requestedports($p)]} {
puts stderr "Excluding $portinfo(name) because it does not support the arm64 arch"
if {[dict exists $requestedports $p]} {
puts stderr "Excluding [dict get $portinfo name] because it does not support the arm64 arch"
}
set outputports($p) 0
dict set outputports $p 0
}
}
i386 {
if {${is_64bit_capable}} {
if {$::macports::os_major >= 18 && $supported_archs ne "" && $supported_archs ne "noarch" && "x86_64" ni $supported_archs} {
if {[info exists requestedports($p)]} {
puts stderr "Excluding $portinfo(name) because it does not support the x86_64 arch"
if {[dict exists $requestedports $p]} {
puts stderr "Excluding [dict get $portinfo name] because it does not support the x86_64 arch"
}
set outputports($p) 0
dict set outputports $p 0
}
} elseif {$supported_archs ne "" && $supported_archs ne "noarch" && ("x86_64" ni $supported_archs || "i386" ni $supported_archs)} {
if {[info exists requestedports($p)]} {
puts stderr "Excluding $portinfo(name) because the ${::macports::macosx_version}_x86_64 builder will build it"
if {[dict exists $requestedports $p]} {
puts stderr "Excluding [dict get $portinfo name] because the ${::macports::macosx_version}_x86_64 builder will build it"
}
set outputports($p) 0
dict set outputports $p 0
}
}
powerpc {
if {$supported_archs ne "" && $supported_archs ne "noarch" && "ppc" ni $supported_archs} {
if {[info exists requestedports($p)]} {
puts stderr "Excluding $portinfo(name) because it does not support the ppc arch"
if {[dict exists $requestedports $p]} {
puts stderr "Excluding [dict get $portinfo name] because it does not support the ppc arch"
}
set outputports($p) 0
dict set outputports $p 0
}
}
default {}
}
} else {
puts stderr "Excluding $portinfo(name) because it failed to open: $result"
set outputports($p) 0
puts stderr "Excluding [dict get $portinfo name] because it failed to open: $result"
dict set outputports $p 0
}
}
}
@@ -348,34 +352,34 @@ while {[llength $todo] > 0} {
mportclose $mport
}
if {$outputports($p) == 1} {
set canonicalnames($p) $portinfo(name)
if {[dict get $outputports $p] == 1} {
dict set canonicalnames $p [dict get $portinfo name]
}
# If $requestedports($p) == 0, we're seeing the port again as a dependency of
# something else and thus need to follow its deps even if it was excluded.
if {$outputports($p) == 1 || ![info exists requestedports($p)] || $requestedports($p) == 0} {
set portdepinfo($p) [list]
if {[dict get $outputports $p] == 1 || ![dict exists $requestedports $p] || [dict get $requestedports $p] == 0} {
dict set portdepinfo $p [list]
foreach depstype $depstypes {
if {[info exists portinfo($depstype)] && $portinfo($depstype) ne ""} {
foreach onedep $portinfo($depstype) {
if {[dict exists $portinfo $depstype] && [dict get $portinfo $depstype] ne ""} {
foreach onedep [dict get $portinfo $depstype] {
set depname [string tolower [lindex [split [lindex $onedep 0] :] end]]
if {[string match port:* $onedep]} {
lappend portdepinfo($p) $depname
dict lappend portdepinfo $p $depname
} else {
# soft deps are installed before their dependents, but
# don't cause exclusion if they are failing
# real problematic example: bin:xattr:xattr
lappend portsoftdeps($p) $depname
dict lappend portsoftdeps $p $depname
}
if {![info exists outputports($depname)]} {
if {![dict exists $outputports $depname]} {
lappend todo $depname
if {$include_deps} {
set outputports($depname) 1
dict set outputports $depname 1
} else {
set outputports($depname) 0
dict set outputports $depname 0
}
} elseif {[info exists requestedports($depname)] && ![info exists portdepinfo($depname)]} {
} elseif {[dict exists $requestedports $depname] && ![dict exists $portdepinfo $depname]} {
# may or may not have been checked for exclusion yet
lappend todo $depname
}
@@ -385,11 +389,9 @@ while {[llength $todo] > 0} {
}
# Mark as having been processed at least once.
if {[info exists requestedports($p)]} {
set requestedports($p) 0
if {[dict exists $requestedports $p]} {
dict set requestedports $p 0
}
array unset portinfo
}
}
@@ -397,20 +399,20 @@ if {$jobs_dir ne "" && $license_db_dir ne "" && $archive_site_public ne "" && $a
write_license_db $license_db_dir
}
set sorted_portnames [lsort -dictionary [array names portdepinfo]]
set sorted_portnames [lsort -dictionary [dict keys $portdepinfo]]
foreach portname $sorted_portnames {
check_failing_deps $portname
}
set portlist [list]
foreach portname $sorted_portnames {
if {[info exists portdepinfo($portname)]} {
if {[dict exists $portdepinfo $portname]} {
process_port_deps $portname
}
}
foreach portname $portlist {
if {$outputports($portname) == 1} {
puts $canonicalnames($portname)
if {[dict get $outputports $portname] == 1} {
puts [dict get $canonicalnames $portname]
}
}
tools/supported-archs.tcl
+6 -7
View File
@@ -31,10 +31,10 @@
# IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
proc split_variants {variants} {
set result {}
set result [dict create]
set l [regexp -all -inline -- {([-+])([[:alpha:]_]+[\w\.]*)} $variants]
foreach { match sign variant } $l {
lappend result $variant $sign
dict set result $variant $sign
}
return $result
}
@@ -64,14 +64,13 @@ if {[catch {set one_result [mportlookup $portname]}] || [llength $one_result] <
exit 1
}
array set portinfo [lindex $one_result 1]
set portname $portinfo(name)
lassign $one_result portname portinfo
if {[info exists portinfo(porturl)]} {
if {[catch {set mport [mportopen $portinfo(porturl) [list subport $portname] $variations]}]} {
if {[dict exists $portinfo porturl]} {
if {[catch {set mport [mportopen [dict get $portinfo porturl] [dict create subport $portname] $variations]}]} {
ui_warn "failed to open port: $portname"
} else {
set archs [_mportkey $mport supported_archs]
puts [expr {$archs ne "" ? $archs : "x86_64 i386 ppc64 ppc"}]
puts [expr {$archs ne "" ? $archs : "arm64 i386 ppc ppc64 x86_64"}]
}
}
tools/uninstall-unneeded-ports.tcl
+22 -22
View File
@@ -41,6 +41,8 @@ if {$showVersion} {
# Create a lookup table for determining whether a port has dependents
# (regardless of whether or not those dependents are currently installed)
set dependents [dict create]
set a_dependency [dict create]
foreach source $macports::sources {
set source [lindex $source 0]
macports_try -pass_signal {
@@ -48,19 +50,16 @@ foreach source $macports::sources {
macports_try -pass_signal {
while {[gets $fd line] >= 0} {
array unset portinfo
set name [lindex $line 0]
set len [lindex $line 1]
set line [read $fd $len]
array set portinfo $line
lassign $line name len
set portinfo [read $fd $len]
# depends_test is not included because mpbb doesn't run `port test'
foreach field {depends_build depends_extract depends_fetch depends_lib depends_patch depends_run} {
if {[info exists portinfo($field)]} {
foreach dependency $portinfo($field) {
foreach field [list depends_build depends_extract depends_fetch depends_lib depends_patch depends_run] {
if {[dict exists $portinfo $field]} {
foreach dependency [dict get $portinfo $field] {
set lowercase_dependency_name [string tolower [lindex [split $dependency :] end]]
incr dependents($lowercase_dependency_name)
set a_dependency($lowercase_dependency_name) $name
dict incr dependents $lowercase_dependency_name
dict set a_dependency $lowercase_dependency_name $name
}
}
}
@@ -80,12 +79,12 @@ proc removal_reason {installed_name} {
global dependents a_dependency
set reason ""
set lowercase_name [string tolower $installed_name]
if {![info exists dependents($lowercase_name)]} {
if {![dict exists $dependents $lowercase_name]} {
set reason "no port in the PortIndex depends on $installed_name"
} elseif {$dependents($lowercase_name) == 1} {
set dependency_reason [removal_reason $a_dependency($lowercase_name)]
} elseif {[dict get $dependents $lowercase_name] == 1} {
set dependency_reason [removal_reason [dict get $a_dependency $lowercase_name]]
if {$dependency_reason ne ""} {
set reason "only $a_dependency($lowercase_name) depends on $installed_name and $dependency_reason"
set reason "only [dict get $a_dependency $lowercase_name] depends on $installed_name and $dependency_reason"
}
}
return $reason
@@ -100,13 +99,15 @@ proc deactivate_with_dependents {e} {
foreach dependent [$e dependents] {
deactivate_with_dependents $dependent
}
if {![registry::run_target $e deactivate [list ports_nodepcheck 1]]
&& [catch {portimage::deactivate [$e name] [$e version] [$e revision] [$e variants] [list ports_nodepcheck 1]} result]} {
set options [dict create ports_nodepcheck 1]
if {![registry::run_target $e deactivate $options]
&& [catch {portimage::deactivate [$e name] [$e version] [$e revision] [$e variants] $options} result]} {
puts stderr $::errorInfo
puts stderr "Deactivating [$e name] @[$e version]_[$e revision][$e variants] failed: $result"
}
}
set uninstall_options [dict create ports_force 1]
foreach port [registry::entry imaged] {
# Set to yes if a port should be uninstalled
set uninstall no
@@ -122,11 +123,10 @@ foreach port [registry::entry imaged] {
ui_msg "Removing ${installed_name} @${installed_version}_${installed_revision}${installed_variants} because it is no longer in the PortIndex"
set uninstall yes
} else {
array unset portinfo
array set portinfo [lindex $portindex_match 1]
set portinfo [lindex $portindex_match 1]
set portspec "$installed_name @${installed_version}_$installed_revision$installed_variants"
if {$portinfo(version) ne $installed_version || $portinfo(revision) != $installed_revision} {
if {[dict get $portinfo version] ne $installed_version || [dict get $portinfo revision] != $installed_revision} {
# The version in the index is different than the installed one
ui_msg "Removing $portspec because there is a newer version in the PortIndex"
set uninstall yes
@@ -139,7 +139,7 @@ foreach port [registry::entry imaged] {
set uninstall no
if {no} {
set lowercase_name [string tolower $installed_name]
ui_msg "Not removing $portspec because it has $dependents($lowercase_name) dependents"
ui_msg "Not removing $portspec because it has [dict get $dependents $lowercase_name] dependents"
}
}
}
@@ -150,9 +150,9 @@ foreach port [registry::entry imaged] {
deactivate_with_dependents $dependent
}
# Try to run the target via the portfile first, so pre/post code runs
if {![registry::run_target $port uninstall [list ports_force 1]]} {
if {![registry::run_target $port uninstall $uninstall_options]} {
# Portfile failed, use the registry directly
registry_uninstall::uninstall $installed_name $installed_version $installed_revision $installed_variants [list ports_force 1]
registry_uninstall::uninstall $installed_name $installed_version $installed_revision $installed_variants $uninstall_options
}
}
}