dtas 0.11.0 → 0.12.0

data/lib/dtas/mlib/migrations/0001_initial.rb

@@ -0,0 +1,42 @@
+# Copyright (C) 2015 all contributors <dtas-all@nongnu.org>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+
+Sequel.migration do
+  up do
+    create_table(:nodes) do
+      primary_key :id
+      String :name, null: false # encoding: binary, POSIX
+      Integer :ctime
+      foreign_key :parent_id, :nodes, null: false # parent dir
+      # >= 0: tlen of track, -2: ignore, -1: directory
+      Integer :tlen, null: false
+      unique [ :parent_id, :name ]
+    end
+
+    create_table(:tags) do
+      primary_key :id
+      String :tag, null: false, unique: true # encoding: US-ASCII
+    end
+
+    create_table(:vals) do
+      primary_key :id
+      String :val, null: false, unique: true # encoding: UTF-8
+    end
+
+    create_table(:comments) do
+      foreign_key :node_id, :nodes, null: false
+      foreign_key :tag_id, :tags, null: false
+      foreign_key :val_id, :vals, null: false
+      primary_key [ :node_id, :tag_id, :val_id ]
+      index :node_id
+      index [ :tag_id, :val_id ]
+    end
+  end
+
+  down do
+    drop_table(:nodes)
+    drop_table(:tags)
+    drop_table(:vals)
+    drop_table(:comments)
+  end
+end

data/lib/dtas/nonblock.rb

@@ -0,0 +1,24 @@
+# Copyright (C) 2015 all contributors <dtas-all@nongnu.org>
+# License: GPL-3.0+ (https://www.gnu.org/licenses/gpl-3.0.txt)
+
+class DTAS::Nonblock < IO
+  if RUBY_VERSION.to_f <= 2.0
+    EX = {}.freeze
+    def read_nonblock(len, buf = nil, opts = EX)
+      super(len, buf)
+    rescue IO::WaitReadable
+      raise if opts[:exception]
+      :wait_readable
+    rescue EOFError
+      raise if opts[:exception]
+      nil
+    end
+
+    def write_nonblock(buf, opts = EX)
+      super(buf)
+    rescue IO::WaitWritable
+      raise if opts[:exception]
+      :wait_writable
+    end
+  end
+end

data/lib/dtas/parse_freq.rb

@@ -0,0 +1,29 @@
+# Copyright (C) 2015 all contributors <dtas-all@nongnu.org>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+
+require_relative '../dtas'
+module DTAS::ParseFreq
+
+  # may return a negative frequency meaning lowpass
+  def parse_freq(val, round = true)
+    case val
+    when String
+      val = val.dup
+      mult = val.sub!(/k\z/, '') ? 1000 : 1
+      val = (val.to_f * mult)
+    when Numeric
+      val
+    else
+      raise ArgumentError, "non-numeric value given"
+    end
+
+    case round
+    when true, :int
+      val.round
+    when :float
+      val.to_f
+    else
+      raise ArgumentError, "usage: parse_freq(val, (true|:round))"
+    end
+  end
+end

data/lib/dtas/parse_time.rb

@@ -1,11 +1,14 @@
+# frozen_string_literal: true
 # Copyright (C) 2013-2015 all contributors <dtas-all@nongnu.org>
 # License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
 require_relative '../dtas'
 
 module DTAS::ParseTime
-  # convert a string time to seconds, returning a Flot or Integer
+  # convert a string time to seconds, returning a Floot or Integer
   def parse_time(time)
     case time
+    when Numeric
+      time
     when /\A\d+\z/
       time.to_i
     when /\A[\d\.]+\z/
@@ -15,7 +18,7 @@ def parse_time(time)
       rv = hhmmss.sub!(/\.(\d+)\z/, "") ? "0.#$1".to_f : 0
 
       # deal with HH:MM:SS
-      t = hhmmss.split(/:/)
+      t = hhmmss.split(':')
       raise ArgumentError, "Bad time format: #{hhmmss}" if t.size > 3
 
       mult = 1

data/lib/dtas/pipe.rb

@@ -6,9 +6,10 @@
 end
 require_relative '../dtas'
 require_relative 'writable_iter'
+require_relative 'nonblock'
 
 # pipe wrapper for -player sinks
-class DTAS::Pipe < IO # :nodoc:
+class DTAS::Pipe < DTAS::Nonblock # :nodoc:
   include DTAS::WritableIter
   attr_accessor :sink
 

data/lib/dtas/player.rb

@@ -190,7 +190,7 @@ def enq_handler(io, msg)
     io.emit("OK")
   end
 
-  def do_enq_head(io, msg)
+  def dpc_enq_head(io, msg)
     # check @queue[0] in case we have no sinks
     if need_to_queue
       @queue.unshift(msg)
@@ -207,53 +207,33 @@ def client_iter(io, msg)
     case command
     when "enq"
       enq_handler(io, msg[0])
-    when "enq-head"
-      do_enq_head(io, msg)
     when "enq-cmd"
       enq_handler(io, { "command" => msg[0]})
     when "pause", "play", "play_pause"
       play_pause_handler(io, command)
-    when "seek"
-      do_seek(io, msg[0])
-    when "clear"
-      @queue.clear
-      wall("clear")
-      io.emit("OK")
-    when "rg"
-      rg_handler(io, msg)
-    when "cue"
-      cue_handler(io, msg)
-    when "skip"
-      skip_handler(io, msg)
-    when "sink"
-      sink_handler(io, msg)
-    when "current"
-      current_handler(io, msg)
-    when "watch"
-      @watchers[io] = true
-      io.emit("OK")
-    when "format"
-      format_handler(io, msg)
-    when "env"
-      env_handler(io, msg)
-    when "restart"
-      restart_pipeline
-      io.emit("OK")
-    when "source"
-      source_handler(io, msg)
-    when "state"
-      state_file_handler(io, msg)
-    when "cd"
-      chdir_handler(io, msg)
     when "pwd"
       io.emit(Dir.pwd)
-    when "tl"
-      tl_handler(io, msg)
-    when "trim"
-      trim_handler(io, msg)
+    else
+      m = "dpc_#{command.tr('-', '_')}"
+      __send__(m, io, msg) if respond_to?(m)
     end
   end
 
+  def dpc_clear(io, msg)
+    @queue.clear
+    wall('clear')
+    io.emit('OK')
+  end
+
+  def dpc_queue(io, msg)
+    'cat' == msg[0] and io.emit(@queue.to_yaml)
+  end
+
+  def dpc_watch(io, _)
+    @watchers[io] = true
+    io.emit('OK')
+  end
+
   def event_loop_iter
     @srv.run_once do |io, msg| # readability handler, request/response
       case io
@@ -307,7 +287,7 @@ def sink_death(sink, status)
     return unless sink.active
 
     if (@current || @queue[0]) && !@paused
-      # we get here if source/sinks are all killed in restart_pipeline
+      # we get here if source/sinks are all killed in dpc_restart
       __sink_activate(sink)
       next_source(_next) unless @current
     end
@@ -426,7 +406,7 @@ def next_source(source_spec)
 
       dst = @sink_buf
       pending.dst_assoc(dst)
-      pending.src_spawn(@format, @rg, out: dst.wr, in: "/dev/null")
+      pending.src_spawn(@format, @rg, out: dst.wr, in: DTAS.null)
 
       # watch and restart on modifications
       pending.respond_to?(:watch_begin) and

data/lib/dtas/player/client_handler.rb

@@ -117,7 +117,7 @@ def __sink_snapshot(sink)
   end
 
   # returns a wait_ctl arg
-  def sink_handler(io, msg)
+  def dpc_sink(io, msg)
     name = msg[1]
     case msg[0]
     when "ls"
@@ -240,7 +240,7 @@ def current_expect_samples(in_samples) # @current.samples
     out_samples(in_samples, @current.format, @format)
   end
 
-  def rg_handler(io, msg)
+  def dpc_rg(io, msg)
     return io.emit(@rg.to_hsh.to_yaml) if msg.empty?
     before = @rg.to_hsh
     msg.each do |kv|
@@ -277,7 +277,7 @@ def active_sinks
 
   # show current info about what's playing
   # returns non-blocking iterator retval
-  def current_handler(io, msg)
+  def dpc_current(io, msg)
     tmp = {}
     if @current
       tmp["current"] = s = @current.to_hsh
@@ -312,6 +312,7 @@ def current_handler(io, msg)
         h
       end
     end
+    tmp['tracklist'] = @tl.to_hsh(false)
     io.emit(tmp.to_yaml)
   end
 
@@ -321,7 +322,7 @@ def __buf_reset(buf) # buf is always @sink_buf for now
     @srv.wait_ctl(buf, :wait_readable)
   end
 
-  def skip_handler(io, msg)
+  def dpc_skip(io, msg)
     __current_drop
     wall("skip")
     io.emit("OK")
@@ -371,7 +372,8 @@ def seek_internal(cur, offset)
     end
   end
 
-  def do_seek(io, offset)
+  def dpc_seek(io, msg)
+    offset = msg[0]
     if @current
       if @current.respond_to?(:infile)
         begin
@@ -408,7 +410,12 @@ def restart_pipeline
     stop_sinks
   end
 
-  def format_handler(io, msg)
+  def dpc_restart(io, _)
+    restart_pipeline
+    io.emit('OK')
+  end
+
+  def dpc_format(io, msg)
     new_fmt = @format.dup
     msg.each do |kv|
       k, v = kv.split(/=/, 2)
@@ -443,7 +450,7 @@ def format_handler(io, msg)
     io.emit("OK")
   end
 
-  def env_handler(io, msg)
+  def dpc_env(io, msg)
     if msg.empty?
       # this may fail for large envs due to SEQPACKET size restrictions
       # do we care?
@@ -465,7 +472,7 @@ def env_handler(io, msg)
     io.emit("OK")
   end
 
-  def source_handler(io, msg)
+  def dpc_source(io, msg)
     map = @source_map
     op = msg.shift
     case op
@@ -509,7 +516,7 @@ def source_handler(io, msg)
     end
   end
 
-  def chdir_handler(io, msg)
+  def dpc_cd(io, msg)
     msg.size == 1 or return io.emit("ERR usage: cd DIRNAME")
     begin
       Dir.chdir(msg[0])
@@ -520,9 +527,27 @@ def chdir_handler(io, msg)
     io.emit("OK")
   end
 
-  def state_file_handler(io, msg)
+  def state_file_dump_async(io, sf)
+    on_death = lambda { |_| @srv.wait_ctl(io, :wait_readable) }
+    pid = fork do
+      begin
+        begin
+          sf.dump(self)
+          res = 'OK'
+        rescue => e
+          res = "ERR dumping to #{xs(sf.path)} #{e.message}"
+        end
+        io.to_io.send(res, Socket::MSG_EOR)
+      ensure
+        exit!(0)
+      end
+    end
+    DTAS::Process::PIDS[pid] = on_death
+  end
+
+  def dpc_state(io, msg)
     case msg.shift
-    when "dump"
+    when 'dump'
       dest = msg.shift
       if dest
         sf = DTAS::StateFile.new(dest, false)
@@ -532,13 +557,9 @@ def state_file_handler(io, msg)
       else
         return io.emit("ERR no state file configured")
       end
-      begin
-        sf.dump(self)
-      rescue => e
-        return io.emit("ERR dumping to #{xs(dest)} #{e.message}")
-      end
+      state_file_dump_async(io, sf)
+      :ignore
     end
-    io.emit("OK")
   end
 
   def _tl_skip
@@ -546,84 +567,144 @@ def _tl_skip
     __current_drop
   end
 
-  def tl_handler(io, msg)
+  def dpc_tl(io, msg)
+    sub = msg.shift
+    m = "_dpc_tl_#{sub.tr('-', '_')}"
+    __send__(m, io, msg) if respond_to?(m)
+  end
+
+  def _dpc_tl_add(io, msg)
+    path = msg.shift
+    after_track_id = msg.shift
+    after_track_id = after_track_id.to_i if after_track_id
+    case set_as_current = msg.shift
+    when 'true' then set_as_current = true
+    when 'false', nil then set_as_current = false
+    else
+      return io.emit('ERR tl add PATH [after_track_id] [true|false]')
+    end
+    begin
+      track_id = @tl.add_track(path, after_track_id, set_as_current)
+      return io.emit('ERR FULL') unless track_id
+    rescue ArgumentError => e
+      return io.emit("ERR #{e.message}")
+    end
+
+    _tl_skip if set_as_current # if @current is playing, it will restart soon
+
+    # start playing if we're currently idle
+    next_source(_next) unless need_to_queue
+    io.emit(track_id.to_s)
+  end
+
+  def _dpc_tl_repeat(io, msg)
+    prev = @tl.repeat.to_s
     case msg.shift
-    when "add"
-      path = msg.shift
-      after_track_id = msg.shift
-      after_track_id = after_track_id.to_i if after_track_id
-      case set_as_current = msg.shift
-      when "true" then set_as_current = true
-      when "false", nil then set_as_current = false
-      else
-        return io.emit("ERR tl add PATH [after_track_id] [true|false]")
-      end
-      begin
-        track_id = @tl.add_track(path, after_track_id, set_as_current)
-      rescue ArgumentError => e
-        return io.emit("ERR #{e.message}")
-      end
+    when 'true' then @tl.repeat = true
+    when 'false' then @tl.repeat = false
+    when '1' then @tl.repeat = 1
+    when nil
+    end
+    io.emit("tl repeat #{prev}")
+  end
 
-      _tl_skip if set_as_current # if @current is playing, it will restart soon
+  def _dpc_tl_shuffle(io, msg)
+    prev = (!!@tl.shuffle).to_s
+    v = msg.shift
+    case v
+    when 'debug' then return io.emit(@tl.shuffle.to_yaml) # TODO: remove
+    when nil
+    else
+      set_bool(io, 'tl shuffle', v) { |b| @tl.shuffle = b }
+    end
+    io.emit("tl shuffle #{prev}")
+  end
 
-      # start playing if we're currently idle
-      next_source(_next) unless need_to_queue
-      io.emit("#{track_id}")
-    when "repeat"
-      case msg.shift
-      when "true" then @tl.repeat = true
-      when "false" then @tl.repeat = false
-      when "1" then @tl.repeat = 1
-      when nil
-        return io.emit("repeat #{@tl.repeat.to_s}")
-      end
-      io.emit("OK")
-    when "remove"
-      track_id = msg.shift or return io.emit("ERR track_id not specified")
-      track_id = track_id.to_i
-      @tl.remove_track(track_id) or return io.emit("MISSING")
-
-      # skip if we're removing the currently playing track
-      if @current && @current.respond_to?(:infile) &&
-         @current.infile.object_id == track_id
-        _tl_skip
-      end
-      # drop it from the queue, too, in case it just got requeued or paused
-      @queue.delete_if { |t| Array === t && t[0].object_id == track_id }
-      io.emit("OK")
-    when "get"
-      res = @tl.get_tracks(msg.map!(&:to_i))
-      res.map! { |tid, file| "#{tid}=#{file ? Shellwords.escape(file) : ''}" }
-      io.emit("#{res.size} #{res.join(' ')}")
-    when "tracks"
-      tracks = @tl.tracks
-      io.emit("#{tracks.size} " << tracks.map!(&:to_s).join(' '))
-    when "goto"
-      track_id = msg.shift or return io.emit("ERR track_id not specified")
-      offset = msg.shift # may be nil
-      if @tl.go_to(track_id.to_i, offset)
-        _tl_skip
-        next_source(_next) unless need_to_queue
-        io.emit("OK")
-      else
-        io.emit("MISSING")
-      end
-    when "current"
-      path = @tl.cur_track
-      io.emit(path ? path : "NONE")
-    when "current-id"
-      path = @tl.cur_track
-      io.emit(path ? path.object_id.to_s : "NONE")
-    when "next"
+  def _dpc_tl_max(io, msg)
+    prev = @tl.max
+    case msg.shift
+    when nil
+    when %r{\A(\d[\d_]*)\z} then @tl.max = $1.to_i
+    else
+      return io.emit('ERR tl max must a non-negative integer')
+    end
+    io.emit("tl max #{prev}")
+  end
+
+  def _dpc_tl_remove(io, msg)
+    track_id = msg.shift or return io.emit('ERR track_id not specified')
+    track_id = track_id.to_i
+    path = @tl.remove_track(track_id) or return io.emit('MISSING')
+    rm = path.object_id
+
+    # skip if we're removing the currently playing track
+    if @current && @current.respond_to?(:infile) &&
+       @current.infile.object_id == rm
       _tl_skip
-      io.emit("OK")
-    when "prev"
-      @tl.previous!
+    end
+    # drop it from the queue, too, in case it just got requeued or paused
+    @queue.delete_if { |t| Array === t && t[0].object_id == rm }
+    io.emit(path)
+  end
+
+  def _dpc_tl_get(io, msg)
+    res = @tl.get_tracks(msg.map!(&:to_i))
+    res.map! { |tid, file| "#{tid}=#{file ? Shellwords.escape(file) : ''}" }
+    io.emit("#{res.size} #{res.join(' ')}")
+  end
+
+  def _dpc_tl_tracks(io, msg)
+    tracks = @tl.tracks
+    io.emit("#{tracks.size} " << tracks.map!(&:to_s).join(' '))
+  end
+
+  def _dpc_tl_goto(io, msg)
+    track_id = msg.shift or return io.emit('ERR track_id not specified')
+    offset = msg.shift # may be nil
+    if @tl.go_to(track_id.to_i, offset)
       _tl_skip
-      io.emit("OK")
+      next_source(_next) unless need_to_queue
+      io.emit('OK')
+    else
+      io.emit('MISSING')
     end
   end
 
+  def _dpc_tl_current(io, msg)
+    track = @tl.cur_track
+    io.emit(track ? track.to_path : 'NONE')
+  end
+
+  def _dpc_tl_current_id(io, msg)
+    track = @tl.cur_track
+    io.emit(track ? track.track_id.to_s : 'NONE')
+  end
+
+  def _dpc_tl_next(io, msg)
+    _tl_skip
+    io.emit('OK')
+  end
+
+  def _dpc_tl_prev(io, msg)
+    @tl.previous!
+    _tl_skip
+    io.emit('OK')
+  end
+
+  def _dpc_tl_clear(io, msg)
+    @tl.clear
+    _tl_skip
+    io.emit('OK')
+  end
+
+  def _dpc_tl_swap(io, msg)
+    usage = 'ERR usage: "tl swap TRACK_ID_A TRACK_ID_B"'
+    a_id = msg.shift or return io.emit(usage)
+    b_id = msg.shift or return io.emit(usage)
+    @tl.swap(a_id.to_i, b_id.to_i) or return io.emit('MISSING')
+    io.emit('OK')
+  end
+
   def __bp_prev_next(io, msg, cur, bp)
     case type = msg[1]
     when nil, "track"
@@ -663,7 +744,7 @@ def __bp_prev_next(io, msg, cur, bp)
     io.emit("OK")
   end
 
-  def cue_handler(io, msg)
+  def dpc_cue(io, msg)
     cur = @current
     if cur.respond_to?(:cuebreakpoints)
       bp = cur.cuebreakpoints
@@ -684,10 +765,10 @@ def cue_handler(io, msg)
     end
   end
 
-  def trim_handler(io, msg)
+  def dpc_trim(io, msg)
+    t = @trim
     case msg.size
-    when 0
-      io.emit({ 'trim' => @trim }.to_yaml)
+    when 0 # OK
     when 1, 2
       case msg[0]
       when 'off'
@@ -706,8 +787,10 @@ def trim_handler(io, msg)
         end
       end
       __current_requeue
-      io.emit('OK')
+    else
+      return io.emit('ERR usage: trim [off|TBEG [TLEN]]')
     end
+    io.emit(t ? t.map(&:to_s).join(' ') : 'off')
   end
 end
 # :startdoc: