527 lines
11 KiB
Plaintext
527 lines
11 KiB
Plaintext
|
|
set ::sweeper::cf "/mod/etc/sweeper.conf"
|
|
|
|
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 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 \
|
|
]
|
|
|
|
set ret [string map $map $str]
|
|
log " Expanded to \[$ret]" 2
|
|
return $ret
|
|
}
|
|
|
|
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]
|
|
}
|
|
|
|
######################################################################
|
|
# Rule criteria
|
|
|
|
proc ::sweeper::flag {ts flag} {
|
|
return [$ts flag $flag]
|
|
}
|
|
|
|
proc ::sweeper::lcn {ts num} {
|
|
return [::sweeper::intcomp [$ts get channel_num] $num]
|
|
}
|
|
|
|
proc ::sweeper::duration {ts dur} {
|
|
return [::sweeper::intcomp [$ts duration] $dur]
|
|
}
|
|
|
|
proc ::sweeper::hour {ts str} {
|
|
set hour [clock format [$ts get start] -format "%H"]
|
|
return [::sweeper::intcomp $hour $str]
|
|
}
|
|
|
|
proc ::sweeper::schedduration {ts dur} {
|
|
return [::sweeper::intcomp [$ts get scheddur] $dur]
|
|
}
|
|
|
|
proc ::sweeper::size {ts size} {
|
|
return [::sweeper::intcomp [$ts size] $size]
|
|
}
|
|
|
|
proc ::sweeper::age {ts age} {
|
|
set recage $(([clock seconds] - [$ts get end]) / 3600)
|
|
log " ... Recording age: $recage" 2
|
|
return [::sweeper::intcomp $recage $age]
|
|
}
|
|
|
|
proc ::sweeper::wage {ts age} {
|
|
set recage $(([clock seconds] - [$ts lastmod]) / 3600)
|
|
log " ... Watched age: $recage" 2
|
|
return [::sweeper::intcomp $recage $age]
|
|
}
|
|
|
|
proc ::sweeper::definition {ts def} {
|
|
return [::sweeper::strcontains [$ts get definition] $def]
|
|
}
|
|
|
|
proc ::sweeper::title {ts str} {
|
|
return [::sweeper::strcontains [$ts get title] $str]
|
|
}
|
|
|
|
proc ::sweeper::synopsis {ts str} {
|
|
return [::sweeper::strcontains [$ts get synopsis] $str]
|
|
}
|
|
|
|
proc ::sweeper::guidance {ts str} {
|
|
return [::sweeper::strcontains [$ts get guidance] $str]
|
|
}
|
|
|
|
proc ::sweeper::genre {ts genre} {
|
|
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} {
|
|
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} {
|
|
return [file exists "[file dirname [$ts get file]]/.$flag"]
|
|
}
|
|
|
|
######################################################################
|
|
|
|
proc ::sweeper::action {ts cmds} {
|
|
global root
|
|
|
|
lassign $cmds cmd rest
|
|
|
|
log "ACTION: $cmd\($rest)" 2
|
|
|
|
switch $cmd {
|
|
continue { return 0 }
|
|
stop { return 1 }
|
|
preserve { return 1 }
|
|
move -
|
|
movecreate {
|
|
set rest [::sweeper::expand $ts $rest]
|
|
if {![file isdirectory "$root/$rest"]} {
|
|
if {$cmd eq "move"} {
|
|
log " ... No such directory $root/$rest" 2
|
|
return 1
|
|
}
|
|
system mkdir_p "$root/$rest"
|
|
if {![file isdirectory "$root/$rest"]} {
|
|
log "Error creating directory $root/$rest" 1
|
|
return 1
|
|
} else {
|
|
log " ... created directory $root/$rest" 2
|
|
}
|
|
}
|
|
log "Moving [$ts get file] to $rest" 0
|
|
foreach f [$ts fileset] {
|
|
log " ....... $f"
|
|
file rename $f "$root/$rest/[file tail $f]"
|
|
if {"$root/$rest" ni $::sweeper::recalc} {
|
|
lappend ::sweeper::recalc "$root/$rest"
|
|
}
|
|
}
|
|
return 1
|
|
}
|
|
lock {
|
|
if {![$ts flag Locked]} {
|
|
log "Locked [$ts get file]" 0
|
|
$ts lock
|
|
}
|
|
return 0
|
|
}
|
|
unlock {
|
|
if {[$ts flag Locked]} {
|
|
log "Unlocked [$ts get file]" 0
|
|
$ts unlock
|
|
}
|
|
return 0
|
|
}
|
|
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} {
|
|
if {$src eq $dst} return
|
|
log "Moving 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
|
|
}
|
|
|
|
foreach f [$ts fileset] {
|
|
log " ....... $f"
|
|
file rename $f "$dst/[file tail $f]"
|
|
}
|
|
}
|
|
if {![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} {
|
|
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 }
|
|
movecreate -
|
|
move {
|
|
set rest [::sweeper::expand $ts $rest]
|
|
if {![file isdirectory "$root/$rest"]} {
|
|
if {$cmd eq "move"} {
|
|
log " ... No such directory $root/$rest" 2
|
|
return 1
|
|
}
|
|
system mkdir_p "$root/$rest"
|
|
if {![file isdirectory "$root/$rest"]} {
|
|
log "Error creating directory $root/$rest" 1
|
|
return 1
|
|
} else {
|
|
log " ... created directory $root/$rest" 2
|
|
}
|
|
}
|
|
::sweeper:folder_merge $folder "$root/$rest"
|
|
return 1
|
|
}
|
|
fileundercreate -
|
|
fileunder {
|
|
if {![file isdirectory "$root/$rest"]} {
|
|
log " ... No such directory $root/$rest" 2
|
|
return 1
|
|
}
|
|
log " - searching for $lfolder under $root/$rest" 2
|
|
set target [::sweeper::find $root/$rest $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 "$root/$rest/$lfolder"
|
|
log "Creating $target" 0
|
|
system mkdir_p $target
|
|
}
|
|
::sweeper:folder_merge $folder $target
|
|
return 1
|
|
}
|
|
lock {
|
|
::sweeper::folder_apply $folder [lambda {ts} {
|
|
if {![$ts flag Locked]} {
|
|
log "Locked [$ts get file]" 0
|
|
$ts lock
|
|
}
|
|
}]
|
|
return 0
|
|
}
|
|
unlock {
|
|
::sweeper::folder_apply $folder [lambda {ts} {
|
|
if {[$ts flag Locked]} {
|
|
log "Unlocked [$ts get file]" 0
|
|
$ts unlock
|
|
}
|
|
}]
|
|
return 0
|
|
}
|
|
default {
|
|
log "Unknown action '$cmd'" 0
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
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]
|
|
log " $cmd\($arg)" 2
|
|
if {$folder && [exists -proc ::sweeper::folder_$cmd]} {
|
|
set ret [::sweeper::folder_$cmd $ts $arg]
|
|
} else {
|
|
set ret [::sweeper::$cmd $ts $arg]
|
|
}
|
|
if {$cmd eq "action"} { return $ret }
|
|
if {!$ret} {
|
|
log " Nomatch" 2
|
|
break
|
|
}
|
|
log " MATCH" 2
|
|
}
|
|
|
|
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
|
|
foreach rule $rules {
|
|
if {[lindex $rule 0] eq "folder"} { incr runfolder }
|
|
}
|
|
|
|
log "" 2
|
|
log "--- SWEEP SCAN STARTING FOR $dir ---" 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/.series"]} {
|
|
log "Not series folder." 2
|
|
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
|
|
}
|
|
|