1234 lines
28 KiB
Plaintext
1234 lines
28 KiB
Plaintext
|
|
require epg.class
|
|
|
|
set ::sweeper::cf "/mod/etc/sweeper.conf"
|
|
set ::sweeper::dryrun 0
|
|
set ::sweeper::lastruleresult 0
|
|
set ::sweeper::stack {}
|
|
set ::sweeper::dustbin [system dustbin 1]
|
|
|
|
proc ::sweeper::unknown {cmd args} {
|
|
log "Unknown sweeper rule clause '$cmd'" 0
|
|
return 0
|
|
}
|
|
|
|
alias ::sweeper::log ::auto::log
|
|
|
|
######################################################################
|
|
# Utility functions
|
|
|
|
proc ::sweeper::skipdir {e} {
|
|
if {[string match {\[*} [string trimleft $e]]} { return 1 }
|
|
if {$e eq $::sweeper::dustbin} { return 1 }
|
|
return 0
|
|
}
|
|
|
|
# Perform an integer comparison.
|
|
proc ::sweeper::intcomp {ref val} {
|
|
lassign $val op num
|
|
|
|
if {$num eq ""} {
|
|
set num $op
|
|
set op "=="
|
|
}
|
|
|
|
return [expr $ref $op $num]
|
|
}
|
|
|
|
# Substring/pattern check
|
|
proc ::sweeper::strcontains {ref val} {
|
|
if {[string index $val 0] eq "~"} {
|
|
return [regexp -nocase -- [string range $val 1 end] $ref]
|
|
}
|
|
if {[string first "*" $val] > -1} {
|
|
return [string match -nocase $val $ref]
|
|
}
|
|
return [expr \
|
|
[string first [string tolower $val] [string tolower $ref]] \
|
|
>= 0]
|
|
}
|
|
|
|
set ::sweeper::expand_fns {
|
|
replace {3 {inline fallback}}
|
|
regsub {3 {inline fallback}}
|
|
asfilename {1 {inline}}
|
|
asuniqfilename {1 {inline}}
|
|
format {2 {inline}}
|
|
var {1 {inline}}
|
|
}
|
|
|
|
proc ::sweeper::expand_fb_replace {ts &ret search replace} {
|
|
set ret [string map [list $search $replace] $ret]
|
|
}
|
|
|
|
proc ::sweeper::expand_fb_regsub {ts &ret search replace} {
|
|
if {[catch {
|
|
regsub -all -- $search $ret $replace ret
|
|
} msg]} {
|
|
log "Error. %regsub - $msg"
|
|
}
|
|
}
|
|
|
|
proc ::sweeper::expand_replace {ts &ret arg search replace} {
|
|
set arg [string map [list $search $replace] $arg]
|
|
return $arg
|
|
}
|
|
|
|
proc ::sweeper::expand_regsub {ts &ret arg search replace} {
|
|
if {[catch {
|
|
regsub -all -- $search $arg $replace arg
|
|
} msg]} {
|
|
log "Error. %regsub - $msg"
|
|
}
|
|
return $arg
|
|
}
|
|
|
|
proc ::sweeper::expand_asfilename {ts &ret arg} {
|
|
return [system filename $arg]
|
|
}
|
|
|
|
proc ::sweeper::expand_asuniqfilename {ts &ret arg} {
|
|
set arg [system filename $arg]
|
|
if {[string index $arg 0] ne "/"} {
|
|
set path "[$ts dir]/$arg"
|
|
} else {
|
|
set path $arg
|
|
}
|
|
if {[file isfile "$path.ts"]} {
|
|
set i 2
|
|
while {[file isfile "${path}_$i.ts"]} { incr i }
|
|
append arg "_$i"
|
|
}
|
|
|
|
return $arg
|
|
}
|
|
|
|
proc ::sweeper::expand_format {ts &ret format arg} {
|
|
if {[catch {set r [format $format $arg]} msg]} {
|
|
log "Error. %format - $msg"
|
|
return "!FORMAT-ERROR!"
|
|
}
|
|
return $r
|
|
}
|
|
|
|
proc ::sweeper::expand_var {ts &ret arg} {
|
|
if {![dict exists $::sweeper::stack $arg]} {
|
|
log "Error. Variable does not exist."
|
|
return ""
|
|
}
|
|
return $::sweeper::stack($arg)
|
|
}
|
|
|
|
# Expand a string containing tokens
|
|
proc ::sweeper::expand {ts str {orig ""}} {
|
|
if {[string first "%" $str] == -1} {
|
|
return $str
|
|
}
|
|
|
|
# First process any extended functions
|
|
|
|
set ret $str
|
|
set fnstack {}
|
|
foreach {fn params} $::sweeper::expand_fns {
|
|
|
|
lassign $params numargs flags
|
|
|
|
set ls -1
|
|
while {[set s [string first "%$fn" $ret]] >= 0} {
|
|
if {$s <= $ls} break
|
|
set ls $s
|
|
|
|
# Fetch the delimiter
|
|
set chpos $($s + [string length $fn] + 1)
|
|
set ch [string index $ret $chpos]
|
|
|
|
#log "Found FN $fn @ $s \[delim:$ch@$chpos]" 2
|
|
|
|
# Extract the arguments
|
|
set pos $chpos
|
|
set fnargs {}
|
|
set e -1
|
|
while {[llength $fnargs] < $numargs} {
|
|
incr pos
|
|
set le $e
|
|
set e [string first $ch $ret $pos]
|
|
if {$e == -1} {
|
|
# Insufficient arguments.
|
|
set argcnt [llength $fnargs]
|
|
if {"fallback" in $flags &&
|
|
"inline" in $flags &&
|
|
[expr $argcnt + 1] == $numargs} {
|
|
log "%$fn - falling back." 2
|
|
set fn "fb_$fn"
|
|
set flags {}
|
|
set e $le
|
|
} else {
|
|
log "Error. %$fn - $argcnt/$numargs parameters found."
|
|
}
|
|
break
|
|
}
|
|
lappend fnargs [::sweeper::expand $ts [
|
|
string range $ret $pos $($e - 1)] $orig]
|
|
set pos $e
|
|
}
|
|
|
|
# s points to the start, e.g. %function
|
|
# e points to the last delimiter or -1 if insufficient
|
|
# arguments were found.
|
|
|
|
if {$e == -1} break
|
|
|
|
if {"inline" in $flags} {
|
|
# For inline functions, replace the call with
|
|
# the result.
|
|
set fnret [
|
|
::sweeper::expand_$fn $ts ret {*}$fnargs]
|
|
set oret $ret
|
|
set ret [string replace $ret $s $e $fnret]
|
|
log " $fn\($oret) -> \[$ret]" 2
|
|
} else {
|
|
# otherwise, queue the function up for later
|
|
# execution.
|
|
lappend fnstack $fn $fnargs
|
|
# and remove the call
|
|
set ret [string replace $ret $s $e]
|
|
}
|
|
}
|
|
}
|
|
#log "FNSTACK: $fnstack" 2
|
|
|
|
lassign [$ts genre_info] genre
|
|
|
|
set start [$ts get start]
|
|
set timestamp [clock format $start -format "%Y%m%d%H%M%S"]
|
|
set yyyymmdd [string range $timestamp 0 7]
|
|
set hhmm [string range $timestamp 8 11]
|
|
set hh [string range $hhmm 0 1]
|
|
set mm [string range $hhmm 2 3]
|
|
|
|
set end [$ts get end]
|
|
set etimestamp [clock format $end -format "%Y%m%d%H%M%S"]
|
|
set eyyyymmdd [string range $etimestamp 0 7]
|
|
set ehhmm [string range $etimestamp 8 11]
|
|
set ehh [string range $ehhmm 0 1]
|
|
set emm [string range $ehhmm 2 3]
|
|
|
|
set map [list \
|
|
"%orig" $orig \
|
|
"%title" [$ts get title] \
|
|
"%genre" $genre \
|
|
"%definition" [$ts get definition] \
|
|
"%synopsis" [$ts get synopsis] \
|
|
"%lcn" [$ts get channel_num] \
|
|
"%channel" [$ts get channel_name] \
|
|
"%duration" [$ts duration] \
|
|
\
|
|
"%filename" [$ts get file] \
|
|
"%basename" [$ts bfile] \
|
|
"%folder" [$ts dir] \
|
|
"%bfolder" [relativedir [$ts dir]] \
|
|
\
|
|
%epname [$ts episode_name] \
|
|
%series [$ts get seriesnum] \
|
|
%episodes [$ts get episodetot] \
|
|
%episode [$ts get episodenum] \
|
|
%epdescr [$ts epstr] \
|
|
\
|
|
"%timestamp" $timestamp \
|
|
"%yyyymmdd" $yyyymmdd \
|
|
"%hhmm" $hhmm \
|
|
"%hh" $hh \
|
|
"%mm" $mm \
|
|
"%year" [clock format $start -format "%Y"] \
|
|
"%month" $(0 + [clock format $start -format "%m"]) \
|
|
"%date" $(0 + [clock format $start -format "%d"]) \
|
|
"%2digityear" [clock format $start -format "%y"] \
|
|
"%2digitmonth" [clock format $start -format "%m"] \
|
|
"%2digitdate" [clock format $start -format "%d"] \
|
|
"%shortday" [clock format $start -format "%a"] \
|
|
"%longday" [clock format $start -format "%A"] \
|
|
"%shortmonth" [clock format $start -format "%b"] \
|
|
"%longmonth" [clock format $start -format "%B"] \
|
|
\
|
|
"%etimestamp" $etimestamp \
|
|
"%eyyyymmdd" $eyyyymmdd \
|
|
"%ehhmm" $ehhmm \
|
|
"%ehh" $ehh \
|
|
"%emm" $emm \
|
|
]
|
|
|
|
#log "STACK: $::sweeper::stack" 2
|
|
|
|
foreach {key val} $::sweeper::stack {
|
|
#log "MAP(%%$key) -> $val" 2
|
|
set map(%%$key) $val
|
|
}
|
|
|
|
#log $map 2
|
|
|
|
set ret [string map $map $ret]
|
|
log " Expanded \[$str] -> \[$ret]" 2
|
|
|
|
# Now call any queued extended functions
|
|
foreach {fn fnargs} $fnstack {
|
|
log " - Calling expand_$fn\($fnargs)" 2
|
|
::sweeper::expand_$fn $ts ret {*}$fnargs
|
|
log " Result: ($ret)" 2
|
|
}
|
|
|
|
return $ret
|
|
}
|
|
|
|
proc ::sweeper::resolvedir {dir} {
|
|
if {$dir eq ""} { return $::auto::root }
|
|
if {[string index $dir 0] eq "/"} { return $dir }
|
|
return "$::auto::root/$dir"
|
|
}
|
|
|
|
proc ::sweeper::relativedir {dir} {
|
|
set dir [string map \
|
|
[list [file normalize $::auto::root] ""] \
|
|
[file normalize $dir]]
|
|
if {[string index $dir 0] eq "/"} {
|
|
set dir [string range $dir 1 end]
|
|
}
|
|
return $dir
|
|
}
|
|
|
|
# returns true if the arguments are actually the same file
|
|
proc ::sweeper::samefile {a b} {
|
|
if {![file exists $a] || ![file exists $b]} { return 0 }
|
|
if {[file stat $a] eq [file stat $b]} { return 1 }
|
|
return 0
|
|
}
|
|
|
|
# Move/copy the set of files which make up a recording
|
|
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]]
|
|
|
|
# Handle cross-filesystem (xfs) moves
|
|
|
|
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 {[::sweeper::samefile $f "$dst/$tail"]} {
|
|
log " Destination is same as source." 0
|
|
return
|
|
}
|
|
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
|
|
}
|
|
}
|
|
if {$op eq "rename"} {
|
|
set ::sweeper::renames($file) "$dst/[file tail $file]"
|
|
}
|
|
return
|
|
}
|
|
|
|
# Otherwise - copy or local FS move.
|
|
|
|
foreach f $fset {
|
|
set tail [file tail $f]
|
|
if {[::sweeper::samefile $f "$dst/$tail"]} {
|
|
log " Destination is same as source." 0
|
|
return
|
|
}
|
|
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
|
|
}
|
|
}
|
|
if {$op eq "rename"} {
|
|
set ::sweeper::renames($file) "$dst/[file tail $file]"
|
|
}
|
|
}
|
|
|
|
# Search for a folder with name 'target' under 'root', skipping 'orig'
|
|
proc ::sweeper::find {root target orig} {
|
|
foreach e [readdir -nocomplain $root] {
|
|
regsub -all -- {//} "$root/$e" "/" entry
|
|
if {![file isdirectory $entry]} continue
|
|
if {[::sweeper::skipdir $e]} 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 ""
|
|
}
|
|
|
|
# Apply a function to all recordings in a directory.
|
|
proc ::sweeper::folder_apply {dir callback args} {
|
|
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 {*}$args
|
|
}
|
|
}
|
|
|
|
proc ::sweeper::rmdir_if_empty {dir} {
|
|
if {$dir eq $::auto::root} return
|
|
if {![system rmdir_if_empty $dir ".series"]} {
|
|
log "Failed to remove directory" 0
|
|
foreach l [system dirblockers $dir] {
|
|
log "Blocking file: $l" 2
|
|
}
|
|
}
|
|
}
|
|
|
|
proc ::sweeper::qrecalc {args} {
|
|
foreach dst $args {
|
|
if {$dst ni $::sweeper::recalc} {
|
|
lappend ::sweeper::recalc $dst
|
|
}
|
|
}
|
|
}
|
|
|
|
######################################################################
|
|
# Rule conditions
|
|
#
|
|
# Parameters:
|
|
# ts - instance of the ts class for the recording being processed.
|
|
# arg - arguments provided for the action.
|
|
# folder - true if the action is being applied to a folder.
|
|
#
|
|
# Return values:
|
|
#
|
|
# 0 - condition does not match.
|
|
# 1 - condition matched.
|
|
|
|
proc ::sweeper::lastrule {ts flag folder} {
|
|
return $::sweeper::lastruleresult
|
|
}
|
|
|
|
proc ::sweeper::flag {ts flag folder} {
|
|
return [$ts flag $flag]
|
|
}
|
|
|
|
proc ::sweeper::queue {ts q folder} {
|
|
set queues [split [{queue status} $ts] ,]
|
|
if {$q eq "any" && [llength $queues]} {
|
|
return 1
|
|
}
|
|
return $($q in $queues)
|
|
}
|
|
|
|
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::now {ts str folder} {
|
|
set now [clock format [clock seconds] -format "%H%M"]
|
|
return [::sweeper::intcomp $now $str]
|
|
}
|
|
|
|
proc ::sweeper::schedduration {ts dur folder} {
|
|
return [::sweeper::intcomp [expr [$ts get scheddur] / 60] $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::bookmarks {ts bookmarks folder} {
|
|
return [::sweeper::intcomp [$ts get bookmarks] $bookmarks]
|
|
}
|
|
|
|
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} {
|
|
lassign [$ts genre_info] tsgenre
|
|
if {$tsgenre eq $genre} { return 1 }
|
|
return 0
|
|
}
|
|
|
|
proc ::sweeper::fflag {ts flag folder} {
|
|
return [file exists "[$ts dir]/.$flag"]
|
|
}
|
|
|
|
proc ::sweeper::foldername {ts str folder} {
|
|
return [::sweeper::strcontains [$ts dir] $str]
|
|
}
|
|
|
|
proc ::sweeper::fileexists {ts str folder} {
|
|
if {[string index $str 0] ne "/"} {
|
|
set str "[$ts dir]/[::sweeper::expand $ts $str]"
|
|
} else {
|
|
set str [::sweeper::expand $ts $str]
|
|
}
|
|
log " FILEEXISTS($str)" 2
|
|
set matches [glob -nocomplain \
|
|
-directory [file dirname $str] \
|
|
-tails [file tail $str]]
|
|
log " Matches($matches)" 2
|
|
return $([llength $matches] > 0)
|
|
}
|
|
|
|
proc ::sweeper::direxists {ts str folder} {
|
|
if {[string index $str 0] ne "/"} {
|
|
set str "[$ts dir]/[::sweeper::expand $ts $str]"
|
|
} else {
|
|
set str [::sweeper::expand $ts $str]
|
|
}
|
|
log " DIREXISTS($str)" 2
|
|
return [file isdirectory $str]
|
|
}
|
|
|
|
proc ::sweeper::series {ts flag folder} {
|
|
if {!$folder} { return 0 }
|
|
set dir [$ts dir]
|
|
if {![file exists "$dir/.series"]} {
|
|
log "Not series folder (nofile)." 2
|
|
return 0
|
|
}
|
|
|
|
# Check if the .series entry is a real one versus one created
|
|
# by ts resetnew
|
|
set fd [open "$dir/.series"]
|
|
set bytes [read $fd]
|
|
close $fd
|
|
set sbytes [unpack $bytes -uintle 160 32]
|
|
if {$sbytes == 0} {
|
|
log "Not series folder." 2
|
|
return 0
|
|
}
|
|
return 1
|
|
}
|
|
|
|
proc ::sweeper::varset {ts var folder} {
|
|
return [dict exists $::sweeper::stack $var]
|
|
}
|
|
|
|
proc ::sweeper::textmatch {ts str folder} {
|
|
if {![regexp -- {^([^~]+)~~(.*)$} $str x target pattern]} {
|
|
log "No pattern in textmatch." 1
|
|
return 0
|
|
}
|
|
log "Textmatch ($target) against ($pattern)" 2
|
|
return [::sweeper::strcontains [::sweeper::expand $ts $target] \
|
|
[::sweeper::expand $ts $pattern]]
|
|
}
|
|
|
|
proc ::sweeper::intmatch {ts str folder} {
|
|
if {![regexp -- {^([^~]+)~~(.*)$} $str x target pattern]} {
|
|
log "No pattern in intmatch." 1
|
|
return 0
|
|
}
|
|
if {[llength [split $pattern " "]] != 2} {
|
|
log "Invalid pattern in numeric comparison." 0
|
|
return 0
|
|
}
|
|
log "Intmatch ($target) against ($pattern)" 2
|
|
return [::sweeper::intcomp [::sweeper::expand $ts $target] $pattern]
|
|
}
|
|
|
|
########################
|
|
# Deprecated conditions
|
|
|
|
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
|
|
}
|
|
}
|
|
# Always matches
|
|
return 1
|
|
}
|
|
|
|
######################################################################
|
|
# Rule actions.
|
|
#
|
|
# Parameters:
|
|
# ts - instance of the ts class for the recording being processed.
|
|
# cmd - name of action being processed.
|
|
# arg - arguments provided for the action.
|
|
# folder - true if the action is being applied to a folder.
|
|
#
|
|
# Return values:
|
|
#
|
|
# 0 - continue to next rule
|
|
# 1 - stop processing
|
|
|
|
proc ::sweeper::action_continue {ts cmd arg folder} {
|
|
return 0
|
|
}
|
|
|
|
proc ::sweeper::action_stop {ts cmd arg folder} {
|
|
return 1
|
|
}
|
|
|
|
alias ::sweeper::action_preserve ::sweeper::action_stop
|
|
|
|
proc ::sweeper::action_move {ts cmd arg folder} {
|
|
set dir [::sweeper::resolvedir [::sweeper::expand $ts $arg]]
|
|
set create 0
|
|
set ocmd $cmd
|
|
if {[string range $cmd end-5 end] eq "create"} {
|
|
set create 1
|
|
set cmd [string range $cmd 0 end-6]
|
|
}
|
|
if {$folder} {
|
|
::sweeper::folder_apply [$ts dir] \
|
|
::sweeper::action_move $ocmd $arg 0
|
|
if {$cmd eq "move"} {
|
|
::sweeper::rmdir_if_empty [$ts dir]
|
|
}
|
|
return 1
|
|
}
|
|
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 $arg" 0
|
|
if {!$::sweeper::dryrun} {
|
|
::sweeper::moveset $ts $dir $cmd
|
|
::sweeper::qrecalc $dir [$ts dir]
|
|
if {$cmd eq "move"} {
|
|
::sweeper::rmdir_if_empty [$ts dir]
|
|
}
|
|
}
|
|
return 1
|
|
}
|
|
|
|
alias ::sweeper::action_movecreate ::sweeper::action_move
|
|
alias ::sweeper::action_copy ::sweeper::action_move
|
|
alias ::sweeper::action_copycreate ::sweeper::action_move
|
|
|
|
proc ::sweeper::action_fileunder {ts cmd arg folder} {
|
|
if {!$folder} {
|
|
log "$cmd action can only be applied to folders."
|
|
return 1
|
|
}
|
|
set dir [::sweeper::resolvedir $arg]
|
|
if {![file isdirectory $dir]} {
|
|
log " ... No such directory $dir" 2
|
|
return 1
|
|
}
|
|
set folder [$ts dir]
|
|
set lfolder [file tail $folder]
|
|
|
|
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} { return 1 }
|
|
|
|
::sweeper::folder_apply $folder [
|
|
lambda {ts target} {
|
|
::sweeper::moveset $ts $target rename
|
|
}] $target
|
|
::sweeper::rmdir_if_empty $folder
|
|
::sweeper::qrecalc $folder $target
|
|
return 1
|
|
}
|
|
|
|
alias ::sweeper::action_fileundercreate ::sweeper::action_fileunder
|
|
|
|
proc ::sweeper::action_renamefile {ts cmd arg folder} {
|
|
set dir [$ts dir]
|
|
if {$folder} {
|
|
::sweeper::folder_apply $dir \
|
|
::sweeper::action_renamefile $cmd $arg 0
|
|
return 0
|
|
}
|
|
set arg [system filename [::sweeper::expand $ts $arg [$ts bfile]]]
|
|
set file [$ts get file]
|
|
log "Renaming $file to $arg" 0
|
|
if {[file exists "$dir/$arg.ts"]} {
|
|
log "... ERROR Target already exists" 0
|
|
return 0
|
|
}
|
|
if {[::sweeper::samefile $file "$dir/$arg.ts"]} {
|
|
log "... ERROR Target is the same as source" 0
|
|
return 0
|
|
}
|
|
if {!$::sweeper::dryrun} {
|
|
ts renamegroup $file $arg
|
|
if {[file exists "$dir/$arg.ts"]} {
|
|
$ts setfile "$dir/$arg.ts"
|
|
set ::sweeper::renames($file) "$dir/$arg.ts"
|
|
} else {
|
|
log "... ERROR renamefile somehow failed" 0
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
proc ::sweeper::action_settitle {ts cmd arg folder} {
|
|
if {$folder} {
|
|
::sweeper::folder_apply [$ts dir] \
|
|
::sweeper::action_settitle $cmd $arg 0
|
|
return 0
|
|
}
|
|
set arg [::sweeper::expand $ts $arg [$ts get title]]
|
|
log "Setting title for [$ts get file] to $arg" 0
|
|
if {!$::sweeper::dryrun} {
|
|
$ts settitle $arg
|
|
}
|
|
return 0
|
|
}
|
|
|
|
proc ::sweeper::action_setguidance {ts cmd arg folder} {
|
|
if {$folder} {
|
|
::sweeper::folder_apply [$ts dir] \
|
|
::sweeper::action_setguidance $cmd $arg 0
|
|
return 0
|
|
}
|
|
set arg [::sweeper::expand $ts $arg [$ts get guidance]]
|
|
log "Setting guidance for [$ts get file] to $arg" 0
|
|
if {!$::sweeper::dryrun} {
|
|
$ts setguidance $arg
|
|
}
|
|
return 0
|
|
}
|
|
|
|
proc ::sweeper::action_setsynopsis {ts cmd arg folder} {
|
|
if {$folder} {
|
|
::sweeper::folder_apply [$ts dir] \
|
|
::sweeper::action_setsynopsis $cmd $arg 0
|
|
return 0
|
|
}
|
|
set arg [::sweeper::expand $ts $arg [$ts get synopsis]]
|
|
log "Setting synopsis for [$ts get file] to $arg" 0
|
|
if {!$::sweeper::dryrun} {
|
|
$ts setsynopsis $arg
|
|
}
|
|
return 0
|
|
}
|
|
|
|
proc ::sweeper::action_lock {ts cmd arg folder} {
|
|
if {$folder} {
|
|
::sweeper::folder_apply [$ts dir] \
|
|
::sweeper::action_lock $cmd 0 0
|
|
return 0
|
|
}
|
|
if {![$ts flag Locked]} {
|
|
log "Locked [$ts get file]" 0
|
|
if {!$::sweeper::dryrun} {
|
|
$ts lock
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
proc ::sweeper::action_unlock {ts cmd arg folder} {
|
|
if {$folder} {
|
|
::sweeper::folder_apply [$ts dir] \
|
|
::sweeper::action_unlock $cmd 0 0
|
|
return 0
|
|
}
|
|
if {[$ts flag Locked]} {
|
|
log "Unlocked [$ts get file]" 0
|
|
if {!$::sweeper::dryrun} {
|
|
$ts unlock
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
proc ::sweeper::action_delete {ts cmd arg folder} {
|
|
if {$folder} {
|
|
::sweeper::folder_apply [$ts dir] \
|
|
::sweeper::action_delete $cmd 0 0
|
|
return
|
|
}
|
|
log "Deleting [$ts get file]" 0
|
|
if {!$::sweeper::dryrun} {
|
|
safe_delete [$ts get file] sweeper
|
|
}
|
|
return 1
|
|
}
|
|
|
|
proc ::sweeper::action_log {ts cmd arg folder} {
|
|
if {$folder} {
|
|
::sweeper::folder_apply [$ts dir] \
|
|
::sweeper::action_log $cmd $arg 0
|
|
return 0
|
|
}
|
|
set arg [::sweeper::expand $ts $arg]
|
|
log "LOG: '$arg'" 0
|
|
return 0
|
|
}
|
|
|
|
proc ::sweeper::action_set {ts cmd arg folder} {
|
|
set val [join [lassign [split $arg =] var] "="]
|
|
set val [::sweeper::expand $ts $val]
|
|
log "Set '$var'='$val'"
|
|
if {![string length $val]} {
|
|
unset -nocomplain $::sweeper::stack($var)
|
|
} else {
|
|
set ::sweeper::stack($var) $val
|
|
}
|
|
return 0
|
|
}
|
|
|
|
proc ::sweeper::action_flag {ts cmd arg folder} {
|
|
log "Flagged [$ts get file] as $arg" 0
|
|
if {!$::sweeper::dryrun} {
|
|
$ts setflag $arg
|
|
} else {
|
|
$ts setflag $arg 1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
proc ::sweeper::action_unflag {ts cmd arg folder} {
|
|
log "Unflagged [$ts get file] as $arg" 0
|
|
if {!$::sweeper::dryrun} {
|
|
$ts unsetflag $arg
|
|
} else {
|
|
$ts unsetflag $arg 1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
proc ::sweeper::action_queue {ts cmd arg folder} {
|
|
log "Queued [$ts get file] for $arg" 0
|
|
set opt [lassign $arg arg]
|
|
log "ARG: ($arg) OPT: ($opt)" 2
|
|
if {!$::sweeper::dryrun} {
|
|
set q [{queue insert} -hold $ts $arg]
|
|
if {[string trim $opt] ne ""} {
|
|
$q set args $opt
|
|
}
|
|
$q submit
|
|
}
|
|
return 0
|
|
}
|
|
|
|
proc ::sweeper::action_dequeue {ts cmd arg folder} {
|
|
log "De-queued [$ts get file] for $arg" 0
|
|
if {!$::sweeper::dryrun} {
|
|
if {$arg eq "all"} {
|
|
{queue delete} $ts
|
|
} else {
|
|
{queue delete} $ts $arg
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
eval_plugins sweeper
|
|
|
|
######################################################################
|
|
# Handle action
|
|
|
|
proc ::sweeper::action {ts cmds folder} {
|
|
lassign $cmds cmd rest
|
|
log "ACTION: $cmd\($rest) \[$folder]" 2
|
|
return [::sweeper::action_$cmd $ts $cmd $rest $folder]
|
|
}
|
|
|
|
######################################################################
|
|
# Handle clauses
|
|
|
|
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
|
|
}
|
|
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 folder} {
|
|
log "Processing \[$rule]" 2
|
|
|
|
if {[string index $rule 0] eq "#" || [llength $rule] < 2} { return 0 }
|
|
|
|
while {[llength $rule] > 1} {
|
|
set rule [lassign $rule cmd arg]
|
|
set ret [::sweeper::clause $folder $cmd $arg $ts]
|
|
if {$cmd eq "action"} {
|
|
set ::sweeper::lastruleresult 1
|
|
return $ret
|
|
}
|
|
if {!$ret} break
|
|
}
|
|
set ::sweeper::lastruleresult 0
|
|
return 0
|
|
}
|
|
|
|
|
|
proc ::sweeper::apply_folder_rules {dir rules} {
|
|
log "" 2
|
|
log " -- FOLDER RULES --" 2
|
|
log "" 2
|
|
foreach e [readdir -nocomplain $dir] {
|
|
set entry "$dir/$e"
|
|
if {![file isdirectory $entry]} continue
|
|
if {[::sweeper::skipdir $e]} continue
|
|
|
|
log "" 2
|
|
log "==== folder $entry ====" 2
|
|
log "" 2
|
|
|
|
if {[file exists "$entry/.nosweep"]} {
|
|
log "No-sweep folder." 2
|
|
continue
|
|
}
|
|
|
|
set ts 0
|
|
foreach de [lsort -command [lambda {a b} {
|
|
upvar entry e
|
|
return $([file mtime "$e/$b"] - [file mtime "$e/$a"])
|
|
}] [lsearch -glob -all -inline \
|
|
[readdir -nocomplain $entry] {*.ts}]] {
|
|
set dentry "$entry/$de"
|
|
|
|
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
|
|
}
|
|
|
|
set ::sweeper::stack {}
|
|
foreach rule $rules {
|
|
if {[llength $rule] < 1} continue
|
|
if {[::sweeper::runrule $ts $rule 1]} break
|
|
}
|
|
}
|
|
}
|
|
|
|
proc ::sweeper::apply_rules {dir rules {depth 0} {seen {}}} {
|
|
|
|
log "" 2
|
|
log "--- SWEEP($depth) STARTING FOR $dir ---" 2
|
|
log "" 2
|
|
|
|
if {$depth > 20} {
|
|
log "ERROR: Maximum recursion depth exceeded." 0
|
|
return
|
|
}
|
|
|
|
file stat $dir st
|
|
set key "$st(dev):$st(ino)"
|
|
if {$key in $seen} {
|
|
log "Already seen $dir ($key)" 2
|
|
return
|
|
}
|
|
lappend seen $key
|
|
|
|
set dirs {}
|
|
foreach e [readdir -nocomplain $dir] {
|
|
set entry "$dir/$e"
|
|
if {[file isdirectory $entry]} {
|
|
if {![::sweeper::skipdir $e] &&
|
|
![file exists "$entry/.nosweep"]} {
|
|
lappend dirs $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
|
|
}
|
|
|
|
set ::sweeper::stack {}
|
|
foreach rule $rules {
|
|
if {[llength $rule] < 3} continue
|
|
set rule [lassign $rule level]
|
|
if {$level < $depth} continue
|
|
if {[::sweeper::runrule $ts $rule 0]} break
|
|
}
|
|
}
|
|
|
|
set moredepth 0
|
|
foreach rule $rules {
|
|
set level [lindex $rule 0]
|
|
if {$level > $depth} {
|
|
incr moredepth
|
|
break
|
|
}
|
|
}
|
|
|
|
# No rules require greater recursion
|
|
if {!$moredepth} return
|
|
|
|
foreach dir $dirs {
|
|
::sweeper::apply_rules $dir $rules $($depth + 1) $seen
|
|
|
|
file stat $dir st
|
|
set key "$st(dev):$st(ino)"
|
|
lappend seen $key
|
|
}
|
|
}
|
|
|
|
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 rules {}
|
|
set folder_rules {}
|
|
foreach rule $_rules {
|
|
if {[string index $rule 0] eq "#"} continue
|
|
switch -- [lindex $rule 0] {
|
|
folder { lappend folder_rules [lrange $rule 1 end] }
|
|
global { lset rule 0 1; lappend rules $rule }
|
|
recurse { lappend rules [lrange $rule 1 end] }
|
|
default { lappend rules [linsert $rule 0 0] }
|
|
}
|
|
}
|
|
|
|
if {[llength $rules]} {
|
|
::sweeper::apply_rules $dir $rules
|
|
}
|
|
|
|
if {[llength $folder_rules]} {
|
|
::sweeper::apply_folder_rules $dir $folder_rules
|
|
}
|
|
|
|
foreach dir $::sweeper::recalc {
|
|
log "Resetting unwatched recording flag for $dir" 0
|
|
ts resetnew $dir
|
|
}
|
|
}
|
|
|
|
# Callback function which is called from scan_run
|
|
proc ::sweeper::sweep {dir} {
|
|
if {$dir eq $::auto::root} return
|
|
apply $dir "$dir/.sweeper"
|
|
}
|
|
|
|
######################################################################
|
|
# Auto API callbacks
|
|
|
|
proc ::sweeper::run {} {
|
|
apply $::auto::root $::sweeper::cf
|
|
::auto::flagscan $::auto::root sweeper ::sweeper::sweep
|
|
}
|
|
|
|
proc ::sweeper::rundir {dir} {
|
|
if {$dir eq $::auto::root} {
|
|
apply $::auto::root $::sweeper::cf
|
|
} elseif {[file exists "$dir/.sweeper"]} {
|
|
apply $dir "$dir/.sweeper"
|
|
}
|
|
}
|
|
|
|
if {[file exists $::sweeper::cf]} {
|
|
::auto::register sweeper 700
|
|
::auto::register_flag sweeper sweeper
|
|
}
|
|
|