763 lines
16 KiB
Plaintext
763 lines
16 KiB
Plaintext
|
|
set ::sweeper::cf "/mod/etc/sweeper.conf"
|
|
set ::sweeper::dryrun 0
|
|
|
|
proc ::sweeper::unknown {cmd args} {
|
|
log "Unknown sweeper rule clause '$cmd'" 0
|
|
return 0
|
|
}
|
|
|
|
######################################################################
|
|
# Helper functions
|
|
|
|
proc ::sweeper::expand {ts str} {
|
|
if {[string first "%" $str] == -1} {
|
|
return $str
|
|
}
|
|
|
|
set glist [ts genrelist]
|
|
set tsg [$ts get genre]
|
|
if {![dict exists $glist $tsg]} {
|
|
set genre "Unknown"
|
|
} else {
|
|
set genre [lindex $glist($tsg) 0]
|
|
}
|
|
|
|
set timestamp [clock format [$ts get start] -format "%Y%m%d%H%M%S"]
|
|
set yyyymmdd [string range $timestamp 0 7]
|
|
set hhmm [string range $timestamp 8 11]
|
|
|
|
set map [list \
|
|
"%title" [$ts get title] \
|
|
"%genre" $genre \
|
|
"%definition" [$ts get definition] \
|
|
"%lcn" [$ts get channel_num] \
|
|
"%channel" [$ts get channel_name] \
|
|
"%duration" [$ts duration] \
|
|
"%timestamp" $timestamp \
|
|
"%yyyymmdd" $yyyymmdd \
|
|
"%hhmm" $hhmm \
|
|
]
|
|
|
|
set ret [string map $map $str]
|
|
log " Expanded \[$str] -> \[$ret]" 2
|
|
return $ret
|
|
}
|
|
|
|
proc ::sweeper::resolvedir {dir} {
|
|
global root
|
|
|
|
if {$dir eq ""} { return $root }
|
|
if {[string index $dir 0] eq "/"} { return $dir }
|
|
return "$root/$dir"
|
|
}
|
|
|
|
proc ::sweeper::intcomp {ref val} {
|
|
lassign $val op num
|
|
|
|
if {$num eq ""} {
|
|
set num $op
|
|
set op "=="
|
|
}
|
|
|
|
return [expr $ref $op $num]
|
|
}
|
|
|
|
proc ::sweeper::strcontains {ref val} {
|
|
return [expr \
|
|
[string first [string tolower $val] [string tolower $ref]] \
|
|
>= 0]
|
|
}
|
|
|
|
proc ::sweeper::moveset {ts dst {op rename}} {
|
|
set file [$ts get file]
|
|
log "${op}set($file) -> $dst" 0
|
|
|
|
# Handle alias for rename
|
|
if {$op eq "move"} { set op "rename" }
|
|
|
|
# Determine whether this is a cross-filesystem move.
|
|
file stat [$ts get file] sts
|
|
file stat $dst std
|
|
set xfs 0
|
|
if {$sts(dev) ne $std(dev)} {
|
|
log " Cross-filesystem - will copy then delete." 0
|
|
set xfs 1
|
|
}
|
|
|
|
set fset [lsort [$ts fileset]]
|
|
|
|
if {$xfs && $op eq "rename"} {
|
|
# For cross-filesystem moves, copy the whole file set
|
|
# and then delete the originals if all the copies were
|
|
# successful.
|
|
foreach f $fset {
|
|
set tail [file tail $f]
|
|
if {[catch {file copy $f "$dst/$tail"} msg]} {
|
|
log " ....... $f: XFS copy failed, $msg." 0
|
|
file delete -force "$dst/$tail"
|
|
log " .... Leaving originals intact." 0
|
|
return
|
|
}
|
|
log " ....... $f: OK" 0
|
|
}
|
|
log " Now deleting original files." 0
|
|
foreach f $fset {
|
|
set tail [file tail $f]
|
|
if {[file exists "$dst/$tail"] &&
|
|
[file size "$dst/$tail"] ==
|
|
[file size $f]} {
|
|
file tdelete $f
|
|
log " ....... $f: OK" 0
|
|
} else {
|
|
log " ....... $f: ERROR, sizes differ." 0
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
# Otherwise - copy or local FS move.
|
|
|
|
foreach f $fset {
|
|
set tail [file tail $f]
|
|
if {$op eq "copy" && [file exists "$dst/$tail"]} {
|
|
if {[file size "$dst/$tail"] == [file size $f]} {
|
|
log " ....... $f: Already copied." 2
|
|
continue
|
|
}
|
|
log "Deleting truncated copy $dst/$tail" 0
|
|
file tdelete "$dst/$tail"
|
|
}
|
|
log " ....... $f"
|
|
if {[catch {file $op $f "$dst/[file tail $f]"} msg]} {
|
|
log "$op failed, $msg.", 0
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
######################################################################
|
|
# Rule conditions
|
|
|
|
proc ::sweeper::flag {ts flag folder} {
|
|
return [$ts flag $flag]
|
|
}
|
|
|
|
proc ::sweeper::lcn {ts num folder} {
|
|
return [::sweeper::intcomp [$ts get channel_num] $num]
|
|
}
|
|
|
|
proc ::sweeper::duration {ts dur folder} {
|
|
return [::sweeper::intcomp [$ts duration] $dur]
|
|
}
|
|
|
|
proc ::sweeper::hour {ts str folder} {
|
|
set hour [clock format [$ts get start] -format "%H"]
|
|
return [::sweeper::intcomp $hour $str]
|
|
}
|
|
|
|
proc ::sweeper::schedduration {ts dur folder} {
|
|
return [::sweeper::intcomp [$ts get scheddur] $dur]
|
|
}
|
|
|
|
proc ::sweeper::size {ts size folder} {
|
|
return [::sweeper::intcomp [$ts size] $size]
|
|
}
|
|
|
|
proc ::sweeper::age {ts age folder} {
|
|
set recage $(([clock seconds] - [$ts get end]) / 3600)
|
|
log " ... Recording age: $recage" 2
|
|
return [::sweeper::intcomp $recage $age]
|
|
}
|
|
|
|
proc ::sweeper::wage {ts age folder} {
|
|
set recage $(([clock seconds] - [$ts lastmod]) / 3600)
|
|
log " ... Watched age: $recage" 2
|
|
return [::sweeper::intcomp $recage $age]
|
|
}
|
|
|
|
proc ::sweeper::definition {ts def folder} {
|
|
return [::sweeper::strcontains [$ts get definition] $def]
|
|
}
|
|
|
|
proc ::sweeper::filename {ts str folder} {
|
|
return [::sweeper::strcontains [$ts bfile] $str]
|
|
}
|
|
|
|
proc ::sweeper::title {ts str folder} {
|
|
return [::sweeper::strcontains [$ts get title] $str]
|
|
}
|
|
|
|
proc ::sweeper::synopsis {ts str folder} {
|
|
return [::sweeper::strcontains [$ts get synopsis] $str]
|
|
}
|
|
|
|
proc ::sweeper::guidance {ts str folder} {
|
|
return [::sweeper::strcontains [$ts get guidance] $str]
|
|
}
|
|
|
|
proc ::sweeper::genre {ts genre folder} {
|
|
set glist [ts genrelist]
|
|
|
|
set tsg [$ts get genre]
|
|
if {![dict exists $glist $tsg]} { return 0 }
|
|
|
|
if {[lindex $glist($tsg) 0] eq $genre} { return 1 }
|
|
return 0
|
|
}
|
|
|
|
proc ::sweeper::lock {ts g folder} {
|
|
if {$g} {
|
|
if {![$ts flag Locked]} {
|
|
log "Locked recording." 0
|
|
$ts lock
|
|
}
|
|
} else {
|
|
if {[$ts flag Locked]} {
|
|
log "Unlocked recording." 0
|
|
$ts unlock
|
|
}
|
|
}
|
|
return 1
|
|
}
|
|
|
|
proc ::sweeper::folder_fflag {ts flag folder} {
|
|
return [file exists "[file dirname [$ts get file]]/.$flag"]
|
|
}
|
|
|
|
######################################################################
|
|
|
|
proc ::sweeper::action {ts cmds folder} {
|
|
global root
|
|
|
|
lassign $cmds cmd rest
|
|
|
|
log "ACTION: $cmd\($rest)" 2
|
|
|
|
switch $cmd {
|
|
continue { return 0 }
|
|
stop { return 1 }
|
|
preserve { return 1 }
|
|
copy -
|
|
copycreate -
|
|
move -
|
|
movecreate {
|
|
set rest [::sweeper::expand $ts $rest]
|
|
set dir [::sweeper::resolvedir $rest]
|
|
set create 0
|
|
if {[string range $cmd end-5 end] eq "create"} {
|
|
set create 1
|
|
set cmd [string range $cmd 0 end-6]
|
|
}
|
|
if {![file isdirectory $dir]} {
|
|
if {!$create} {
|
|
log " ... No such directory $dir" 2
|
|
return 1
|
|
}
|
|
if {!$::sweeper::dryrun} {
|
|
system mkdir_p $dir
|
|
if {![file isdirectory $dir]} {
|
|
log "Error creating $dir" 1
|
|
return 1
|
|
} else {
|
|
log " ... created $dir" 2
|
|
}
|
|
}
|
|
}
|
|
log "$cmd [$ts get file] to $rest" 0
|
|
if {!$::sweeper::dryrun} {
|
|
::sweeper::moveset $ts $dir $cmd
|
|
if {"$dir" ni $::sweeper::recalc} {
|
|
lappend ::sweeper::recalc $dir
|
|
}
|
|
}
|
|
return 1
|
|
}
|
|
renamefile {
|
|
set rest [system filename [::sweeper::expand $ts $rest]]
|
|
set file [$ts get file]
|
|
log "Renaming [$ts get file] to $rest" 0
|
|
if {[file exists "[file dirname $file]/$rest.ts"]} {
|
|
log "... ERROR Target already exists" 0
|
|
return 0
|
|
}
|
|
if {!$::sweeper::dryrun} {
|
|
ts renamegroup $file $rest
|
|
}
|
|
return 0
|
|
}
|
|
lock {
|
|
if {![$ts flag Locked]} {
|
|
log "Locked [$ts get file]" 0
|
|
if {!$::sweeper::dryrun} {
|
|
$ts lock
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
unlock {
|
|
if {[$ts flag Locked]} {
|
|
log "Unlocked [$ts get file]" 0
|
|
if {!$::sweeper::dryrun} {
|
|
$ts unlock
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
delete {
|
|
log "Deleting [$ts get file]" 0
|
|
if {!$::sweeper::dryrun} {
|
|
safe_delete [$ts get file] sweeper
|
|
}
|
|
return 1
|
|
}
|
|
default {
|
|
log "Unknown action '$cmd'" 0
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
proc ::sweeper::find {root target orig} {
|
|
set dustbin [system dustbin 1]
|
|
foreach e [readdir -nocomplain $root] {
|
|
regsub -all -- {//} "$root/$e" "/" entry
|
|
if {![file isdirectory $entry]} continue
|
|
if {[string match {\[*} $e]} continue
|
|
if {$e eq $dustbin} continue
|
|
if {$entry eq $orig} continue
|
|
|
|
if {$e eq $target} { return $entry }
|
|
set ret [::sweeper::find $entry $target $orig]
|
|
if {$ret ne ""} { return $ret }
|
|
}
|
|
return ""
|
|
}
|
|
|
|
proc ::sweeper::folder_apply {dir callback} {
|
|
log "Applying action to recordings in $dir" 2
|
|
foreach e [readdir -nocomplain $dir] {
|
|
if {![string match {*.ts} $e]} continue
|
|
set entry "$dir/$e"
|
|
|
|
log "+ folder_apply processing $entry" 2
|
|
|
|
if {[catch {set ts [ts fetch $entry]} msg} {
|
|
log "Error reading TS file, $msg" 0
|
|
continue
|
|
}
|
|
|
|
if {$ts == "0"} {
|
|
log "Invalid TS file." 2
|
|
continue
|
|
}
|
|
|
|
if {[$ts inuse]} {
|
|
log "Recording in use." 2
|
|
continue
|
|
}
|
|
$callback $ts
|
|
}
|
|
}
|
|
|
|
proc ::sweeper:folder_merge {src dst {op rename}} {
|
|
if {$src eq $dst} return
|
|
if {$op eq "move"} { set op "rename" }
|
|
log "$op recordings from $src to $dst" 0
|
|
foreach e [readdir -nocomplain $src] {
|
|
if {![string match {*.ts} $e]} continue
|
|
set entry "$src/$e"
|
|
|
|
log "+ Sweeper processing $entry" 2
|
|
|
|
if {[catch {set ts [ts fetch $entry]} msg} {
|
|
log "Error reading TS file, $msg" 0
|
|
continue
|
|
}
|
|
|
|
if {$ts == "0"} {
|
|
log "Invalid TS file." 2
|
|
continue
|
|
}
|
|
|
|
if {[$ts inuse]} {
|
|
log "Recording in use." 2
|
|
continue
|
|
}
|
|
|
|
::sweeper::moveset $ts $dst $op
|
|
}
|
|
if {$op eq "rename" && ![system rmdir_if_empty $src]} {
|
|
log "Failed to remove directory" 0
|
|
foreach l [system rmdir_if_empty $src 1] {
|
|
log "Blocking file: $l" 0
|
|
}
|
|
}
|
|
if {$dst ni $::sweeper::recalc} {
|
|
lappend ::sweeper::recalc $dst
|
|
}
|
|
}
|
|
|
|
proc ::sweeper::folder_action {ts cmds folder} {
|
|
global root
|
|
|
|
lassign $cmds cmd rest
|
|
|
|
set folder [file dirname [$ts get file]]
|
|
set lfolder [file tail $folder]
|
|
|
|
log "FOLDER ACTION: $cmd\($rest) @\[$folder]" 2
|
|
|
|
switch $cmd {
|
|
continue { return 0 }
|
|
stop { return 1 }
|
|
preserve { return 1 }
|
|
copycreate -
|
|
copy -
|
|
movecreate -
|
|
move {
|
|
set rest [::sweeper::expand $ts $rest]
|
|
set dir [::sweeper::resolvedir $rest]
|
|
set create 0
|
|
if {[string range $cmd end-5 end] eq "create"} {
|
|
set create 1
|
|
set cmd [string range $cmd 0 end-6]
|
|
}
|
|
if {![file isdirectory $dir]} {
|
|
if {!$create} {
|
|
log " ... No such directory $dir" 2
|
|
return 1
|
|
}
|
|
if {!$::sweeper::dryrun} {
|
|
system mkdir_p $dir
|
|
if {![file isdirectory $dir]} {
|
|
log "Error creating $dir" 1
|
|
return 1
|
|
} else {
|
|
log " ... created $dir" 2
|
|
}
|
|
}
|
|
}
|
|
if {!$::sweeper::dryrun} {
|
|
::sweeper:folder_merge $folder $dir $cmd
|
|
}
|
|
return 1
|
|
}
|
|
fileundercreate -
|
|
fileunder {
|
|
set dir [::sweeper::resolvedir $rest]
|
|
if {![file isdirectory $dir]} {
|
|
log " ... No such directory $dir" 2
|
|
return 1
|
|
}
|
|
log " - searching for $lfolder under $dir" 2
|
|
set target [::sweeper::find $dir $lfolder $folder]
|
|
log " = $target" 2
|
|
if {$target eq "" || ![file isdirectory $target]} {
|
|
log "Did not find directory." 2
|
|
if {$cmd ne "fileundercreate"} { return 1 }
|
|
set target "$dir/$lfolder"
|
|
if {$target eq $folder} {
|
|
log "Skipping merge to self." 2
|
|
return 1
|
|
}
|
|
|
|
log "Creating $target" 0
|
|
if {!$::sweeper::dryrun} {
|
|
system mkdir_p $target
|
|
}
|
|
}
|
|
if {!$::sweeper::dryrun} {
|
|
::sweeper:folder_merge $folder $target
|
|
}
|
|
return 1
|
|
}
|
|
renamefile {
|
|
::sweeper::folder_apply $folder [lambda {ts} {
|
|
set rest [system filename \
|
|
[::sweeper::expand $ts $rest]]
|
|
set file [$ts get file]
|
|
log "Renaming [$ts get file] to $rest" 0
|
|
if {[file exists "[file dirname $file]/$rest.ts"]} {
|
|
log "... ERROR Target already exists" 0
|
|
return 0
|
|
}
|
|
if {!$::sweeper::dryrun} {
|
|
ts renamegroup $file $rest
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
lock {
|
|
if {$::sweeper::dryrun} { return 0 }
|
|
::sweeper::folder_apply $folder [lambda {ts} {
|
|
if {![$ts flag Locked]} {
|
|
log "Locked [$ts get file]" 0
|
|
$ts lock
|
|
}
|
|
}]
|
|
return 0
|
|
}
|
|
unlock {
|
|
if {$::sweeper::dryrun} { return 0 }
|
|
::sweeper::folder_apply $folder [lambda {ts} {
|
|
if {[$ts flag Locked]} {
|
|
log "Unlocked [$ts get file]" 0
|
|
$ts unlock
|
|
}
|
|
}]
|
|
return 0
|
|
}
|
|
delete {
|
|
::sweeper::folder_apply $folder [lambda {ts} {
|
|
log "Deleting [$ts get file]" 0
|
|
if {!$::sweeper::dryrun} {
|
|
safe_delete [$ts get file] sweeper
|
|
}
|
|
}]
|
|
return 1
|
|
}
|
|
default {
|
|
log "Unknown action '$cmd'" 0
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
proc ::sweeper::or {ts clause folder} {
|
|
log " --> OR:" 2
|
|
set ret 0
|
|
while {[llength $clause] > 1} {
|
|
set clause [lassign $clause cmd arg]
|
|
set ret [::sweeper::clause $folder $cmd $arg $ts]
|
|
if {$ret} {
|
|
log " <-- OR true." 2
|
|
break
|
|
}
|
|
}
|
|
if {!$ret} {
|
|
log " <-- OR false." 2
|
|
}
|
|
return $ret
|
|
}
|
|
|
|
proc ::sweeper::and {ts clause folder} {
|
|
log " --> AND:" 2
|
|
set ret 0
|
|
while {[llength $clause] > 1} {
|
|
set clause [lassign $clause cmd arg]
|
|
set ret [::sweeper::clause $folder $cmd $arg $ts]
|
|
if {!$ret} {
|
|
log " <-- AND false." 2
|
|
break
|
|
}
|
|
}
|
|
if {$ret} {
|
|
log " <-- AND true." 2
|
|
}
|
|
return $ret
|
|
}
|
|
|
|
proc ::sweeper::clause {folder cmd arg ts} {
|
|
log " $cmd\($arg)" 2
|
|
|
|
if {[string index $cmd 0] eq "!"} {
|
|
set negate 1
|
|
set cmd [string range $cmd 1 end]
|
|
} else {
|
|
set negate 0
|
|
}
|
|
if {$folder && [exists -proc ::sweeper::folder_$cmd]} {
|
|
set ret [::sweeper::folder_$cmd $ts $arg $folder]
|
|
} else {
|
|
set ret [::sweeper::$cmd $ts $arg $folder]
|
|
}
|
|
if {$cmd eq "action"} { return $ret }
|
|
if {$negate} { set ret $(!$ret) }
|
|
if {!$ret} {
|
|
log " Nomatch" 2
|
|
} else {
|
|
log " MATCH" 2
|
|
}
|
|
return $ret
|
|
}
|
|
|
|
proc ::sweeper::runrule {ts rule} {
|
|
log "Processing \[$rule]" 2
|
|
|
|
if {[string index $rule 0] eq "#" || [llength $rule] < 2} { return 0 }
|
|
|
|
set folder 0
|
|
if {[lindex $rule 0] eq "folder"} {
|
|
set folder 1
|
|
set rule [lrange $rule 1 end]
|
|
}
|
|
while {[llength $rule] > 1} {
|
|
set rule [lassign $rule cmd arg]
|
|
set ret [::sweeper::clause $folder $cmd $arg $ts]
|
|
if {$cmd eq "action"} { return $ret }
|
|
if {!$ret} break
|
|
}
|
|
|
|
return 0
|
|
}
|
|
|
|
proc ::sweeper::apply {dir cf} {
|
|
if {[catch {set fp [open $cf r]} msg]} {
|
|
log "Error opening sweeper ruleset ($cf), $msg" 0
|
|
return
|
|
}
|
|
|
|
set ::sweeper::recalc {}
|
|
|
|
set rules [split [read $fp] "\n"]
|
|
$fp close
|
|
|
|
set runfolder 0
|
|
set nrules 0
|
|
foreach rule $rules {
|
|
if {[lindex $rule 0] eq "folder"} { incr runfolder }
|
|
if {[string index $rule 0] ne "#" && [llength $rule] > 1} {
|
|
incr nrules
|
|
}
|
|
}
|
|
|
|
if {!$nrules} return
|
|
|
|
log "" 2
|
|
log "--- SWEEP SCAN STARTING FOR $dir ($nrules) ---" 2
|
|
log "" 2
|
|
|
|
foreach e [readdir -nocomplain $dir] {
|
|
set entry "$dir/$e"
|
|
if {[file isdirectory $entry]} continue
|
|
if {![string match {*.ts} $entry]} continue
|
|
|
|
log "+ Sweeper processing $entry" 2
|
|
|
|
if {[catch {set ts [ts fetch $entry]} msg} {
|
|
log "Error reading TS file, $msg" 0
|
|
continue
|
|
}
|
|
|
|
if {$ts == "0"} {
|
|
log "Invalid TS file." 2
|
|
continue
|
|
}
|
|
|
|
if {[$ts inuse]} {
|
|
log "Recording in use." 2
|
|
continue
|
|
}
|
|
|
|
foreach rule $rules {
|
|
if {[lindex $rule 0] eq "folder"} continue
|
|
if {[string index $rule 0] eq "#" ||
|
|
[llength $rule] < 2} continue
|
|
if {[::sweeper::runrule $ts $rule]} break
|
|
}
|
|
}
|
|
|
|
if {$runfolder > 0} {
|
|
log "" 2
|
|
log " -- FOLDER RULES --" 2
|
|
log "" 2
|
|
set dustbin [system dustbin 1]
|
|
foreach e [readdir -nocomplain $dir] {
|
|
set entry "$dir/$e"
|
|
if {![file isdirectory $entry]} continue
|
|
if {[string match {\[*} $e]} continue
|
|
if {$e eq $dustbin} continue
|
|
|
|
log "" 2
|
|
log "==== folder $entry ====" 2
|
|
log "" 2
|
|
|
|
if {[file exists "$entry/.nosweep"]} {
|
|
log "No-sweep folder." 2
|
|
continue
|
|
}
|
|
|
|
if {![file exists "$entry/.series"]} {
|
|
log "Not series folder." 2
|
|
continue
|
|
}
|
|
|
|
# Check if the .series entry is a real one versus one created
|
|
# by ts resetnew
|
|
set fd [open "$entry/.series"]
|
|
set bytes [read $fd]
|
|
close $fd
|
|
set sbytes [unpack $bytes -uintle 160 32]
|
|
if {$sbytes == 0} {
|
|
log ".series file was auto-created, skipping folder."
|
|
continue
|
|
}
|
|
|
|
set ts 0
|
|
foreach de [readdir -nocomplain $entry] {
|
|
set dentry "$entry/$de"
|
|
if {[file isdirectory $dentry]} {
|
|
set ts 0
|
|
break
|
|
}
|
|
if {$ts ne "0"} continue
|
|
if {![string match {*.ts} $dentry]} continue
|
|
|
|
log " --- Considering $dentry" 2
|
|
|
|
if {[catch {set ts [ts fetch $dentry]} msg} {
|
|
log "Error reading TS file, $msg" 2
|
|
continue
|
|
}
|
|
|
|
if {$ts == "0"} {
|
|
log "Invalid TS file." 2
|
|
continue
|
|
}
|
|
|
|
if {[$ts inuse]} {
|
|
log "Recording in use." 2
|
|
set ts 0
|
|
continue
|
|
}
|
|
break
|
|
}
|
|
|
|
if {$ts == "0"} {
|
|
log "No usable recordings in folder." 2
|
|
continue
|
|
}
|
|
|
|
foreach rule $rules {
|
|
if {[string index $rule 0] eq "#" ||
|
|
[llength $rule] < 2} continue
|
|
if {[lindex $rule 0] ne "folder"} continue
|
|
if {[::sweeper::runrule $ts $rule]} break
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
foreach dir $::sweeper::recalc {
|
|
log "Resetting unwatched recording flag for $dir" 0
|
|
ts resetnew $dir
|
|
}
|
|
}
|
|
|
|
proc ::sweeper::sweep {dir} {
|
|
if {$dir eq $::root} return
|
|
::sweeper::apply $dir "$dir/.sweeper"
|
|
}
|
|
|
|
proc ::sweeper::scan {args} {
|
|
::sweeper::apply $::root $::sweeper::cf
|
|
scan_run $::root sweeper ::sweeper::sweep
|
|
}
|
|
|
|
if {[file exists $::sweeper::cf]} {
|
|
register postdecryptscan ::sweeper::scan
|
|
}
|
|
|