kaede 0.1.0

data/lib/kaede/dbus.rb

@@ -0,0 +1,5 @@
+module Kaede
+  module DBus
+    DESTINATION = 'cc.wanko.kaede1'
+  end
+end

data/lib/kaede/dbus/generator.rb

@@ -0,0 +1,32 @@
+require 'nokogiri'
+require 'kaede/dbus'
+
+module Kaede
+  module DBus
+    class Generator
+      def generate_policy(user)
+        Nokogiri::XML::Builder.new do |xml|
+          xml.comment 'Put this policy configuration file into /etc/dbus-1/system.d'
+          xml.doc.create_internal_subset(
+            'busconfig',
+            '-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN',
+            'http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd',
+          )
+          xml.busconfig do
+            xml.policy(user: 'root') do
+              xml.allow(own: DESTINATION)
+            end
+            xml.policy(user: user) do
+              xml.allow(own: DESTINATION)
+            end
+
+            xml.policy(context: 'default') do
+              xml.allow(send_destination: DESTINATION)
+              xml.allow(receive_sender: DESTINATION)
+            end
+          end
+        end.to_xml
+      end
+    end
+  end
+end

data/lib/kaede/dbus/program.rb

@@ -0,0 +1,125 @@
+require 'dbus'
+require 'nokogiri'
+require 'time'
+
+module Kaede
+  module DBus
+    class Program < ::DBus::Object
+      PATH = '/cc/wanko/kaede1/program'
+      PROPERTY_INTERFACE = 'org.freedesktop.DBus.Properties'
+      INTROSPECT_INTERFACE = 'org.freedesktop.DBus.Introspectable'
+      PROGRAM_INTERFACE = 'cc.wanko.kaede1.Program'
+
+      def initialize(program, enqueued_at)
+        super("#{PATH}/#{program.pid}")
+        @program = program
+        @enqueued_at = enqueued_at
+      end
+
+      def to_xml
+        Nokogiri::XML::Builder.new do |xml|
+          xml.doc.create_internal_subset(
+            'node',
+            '-//freedesktop//DTD D-BUS Object Introspection 1.0//EN',
+            'http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd',
+          )
+          xml.node do
+            xml.interface(name: INTROSPECT_INTERFACE) do
+              xml.method_(name: 'Introspect') do
+                xml.arg(name: 'data', direction: 'out', type: 's')
+              end
+            end
+
+            xml.interface(name: PROPERTY_INTERFACE) do
+              xml.method_(name: 'Get') do
+                xml.arg(name: 'interface', direction: 'in', type: 's')
+                xml.arg(name: 'property', direction: 'in', type: 's')
+                xml.arg(name: 'value', direction: 'out', type: 'v')
+              end
+
+              xml.method_(name: 'GetAll') do
+                xml.arg(name: 'interface', direction: 'in', type: 's')
+                xml.arg(name: 'properties', direction: 'out', type: 'a{sv}')
+              end
+
+              xml.method_(name: 'Set') do
+                xml.arg(name: 'interface', direction: 'in', type: 's')
+                xml.arg(name: 'property', direction: 'in', type: 's')
+                xml.arg(name: 'value', direction: 'in', type: 'v')
+              end
+            end
+
+            xml.interface(name: PROGRAM_INTERFACE) do
+              properties.each_key do |key|
+                xml.property(name: key, type: 's', access: 'read')
+              end
+            end
+          end
+        end.to_xml
+      end
+
+      dbus_interface PROPERTY_INTERFACE do
+        dbus_method :Get, 'in interface:s, in property:s, out value:v' do |iface, prop|
+          case iface
+          when PROGRAM_INTERFACE
+            if properties.has_key?(prop)
+              [properties[prop]]
+            else
+              raise_unknown_property!
+            end
+          else
+            raise_unknown_property!
+          end
+        end
+
+        dbus_method :GetAll, 'in interface:s, out properties:a{sv}' do |iface|
+          case iface
+          when PROGRAM_INTERFACE
+            [properties]
+          when PROGRAM_INTERFACE
+            [{}]
+          else
+            unknown_interface!
+          end
+        end
+
+        dbus_method :Set, 'in interface:s, in property:s, in value:v' do |iface, prop, val|
+          raise_access_denied!
+        end
+      end
+
+      dbus_interface PROGRAM_INTERFACE do
+      end
+
+      def properties
+        @properties ||= {
+          'Pid' => @program.pid,
+          'Tid' => @program.tid,
+          'StartTime' => @program.start_time.iso8601,
+          'EndTime' => @program.end_time.iso8601,
+          'ChannelName' => @program.channel_name,
+          'ChannelForSyoboi' => @program.channel_for_syoboi,
+          'ChannelForRecorder' => @program.channel_for_recorder,
+          'Count' => @program.count,
+          'StartOffset' => @program.start_offset,
+          'SubTitle' => @program.subtitle,
+          'Title' => @program.title,
+          'Comment' => @program.comment,
+          'EnqueuedAt' => @enqueued_at.iso8601,
+        }
+      end
+
+      def raise_unknown_interface!
+        raise ::DBus.error('org.freedesktop.DBus.Error.UnknownInterface')
+      end
+
+      def raise_unknown_property!
+        raise ::DBus.error('org.freedesktop.DBus.Error.UnknownProperty')
+      end
+
+      def raise_access_denied!
+        raise ::DBus.error('org.freedesktop.DBus.Error.AccessDenied')
+      end
+    end
+  end
+end

data/lib/kaede/dbus/scheduler.rb

@@ -0,0 +1,28 @@
+require 'dbus'
+
+module Kaede
+  module DBus
+    class Scheduler < ::DBus::Object
+      PATH = '/cc/wanko/kaede1/scheduler'
+      SCHEDULER_INTERFACE = 'cc.wanko.kaede1.Scheduler'
+
+      def initialize(reload_event, stop_event)
+        super(PATH)
+        @reload_event = reload_event
+        @stop_event = stop_event
+      end
+
+      dbus_interface SCHEDULER_INTERFACE do
+        dbus_method :Reload do
+          @reload_event.incr(1)
+          nil
+        end
+
+        dbus_method :Stop do
+          @stop_event.incr(1)
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/kaede/notifier.rb

@@ -0,0 +1,72 @@
+# coding: utf-8
+require 'kaede'
+
+module Kaede
+  class Notifier
+    def initialize
+      @twitter = Kaede.config.twitter
+      @twitter_target = Kaede.config.twitter_target
+    end
+
+    def notify_before_record(program)
+      tweet("#{format_title(program)}を録画する")
+    end
+
+    def notify_after_record(program)
+      tweet(
+        sprintf(
+          "%sを録画した。ファイルサイズ約%.2fGB。残り約%dGB\n",
+          format_title(program),
+          ts_filesize(program),
+          available_disk,
+        )
+      )
+    end
+
+    def notify_exception(exception, program)
+      msg = "#{program.title}(PID #{program.pid}) の録画中に #{exception.class} で失敗した……"
+      if @twitter_target
+        msg = "@#{@twitter_target} #{msg}"
+      end
+      tweet(msg)
+    end
+
+    def format_title(program)
+      buf = "#{program.channel_name}で「#{program.title}"
+      if program.count
+        buf += " ##{program.count}"
+      end
+      buf += " #{program.subtitle}」"
+      buf
+    end
+
+    def ts_filesize(program)
+      in_gigabyte(record_path(program).size.to_f)
+    end
+
+    # FIXME: duplicate
+    def record_path(program)
+      Kaede.config.record_dir.join("#{program.tid}_#{program.pid}.ts")
+    end
+
+    def available_disk
+      _, avail = `#{Kaede.config.statvfs} #{Kaede.config.record_dir}`.chomp.split(/\s/, 2).map(&:to_i)
+      in_gigabyte(avail)
+    end
+
+    def in_gigabyte(size)
+      size / (1024 * 1024 * 1024)
+    end
+
+    def tweet(text)
+      return unless @twitter
+      Thread.start do
+        begin
+          @twitter.update(text)
+        rescue Exception => e
+          $stderr.puts "Failed to tweet: #{text}: #{e.class}: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/kaede/program.rb

@@ -0,0 +1,39 @@
+# coding: utf-8
+
+module Kaede
+  class Program < Struct.new(:pid, :tid, :start_time, :end_time, :channel_name, :channel_for_syoboi, :channel_for_recorder, :count, :start_offset, :subtitle, :title, :comment)
+    def self.from_xml(doc)
+      doc.xpath('//progitem').map do |item|
+        prog = self.new
+        prog.pid = item['pid'].to_i
+        prog.tid = item['tid'].to_i
+        prog.start_time = Time.parse(item['sttime'])
+        prog.end_time = Time.parse(item['edtime'])
+        prog.channel_for_syoboi = item['chid'].to_i
+        prog.count = item['count'].to_i
+        prog.start_offset = item['stoffset'].to_i # in second
+        prog.subtitle = item['subtitle']
+        prog.title = item['title']
+        prog.comment = item['progcomment']
+        prog
+      end
+    end
+
+    def syoboi_url
+      "http://cal.syoboi.jp/tid/#{tid}##{pid}"
+    end
+
+    def formatted_fname
+      @formatted_fname ||= format_fname
+    end
+
+    def format_fname
+      fname = "#{tid}_#{pid} #{title} ##{count} #{subtitle}#{comment.empty? ? '' : " (#{comment})"} at #{channel_name}"
+      fname = fname.gsub('/', '／')
+      if fname.bytesize >= 200
+        fname = "#{tid}_#{pid} #{title} ##{count} at #{channel_name}"
+      end
+      fname
+    end
+  end
+end

data/lib/kaede/recorder.rb

@@ -0,0 +1,150 @@
+require 'date'
+require 'open3'
+require 'fileutils'
+
+module Kaede
+  class Recorder
+    def initialize(notifier)
+      @notifier = notifier
+    end
+
+    def record(db, pid)
+      program = db.get_program(pid)
+      before_record(program)
+
+      puts "Start #{pid} #{program.syoboi_url}"
+      do_record(program)
+
+      program = db.get_program(pid)
+      puts "Done #{pid} #{program.syoboi_url}"
+      after_record(program)
+    rescue Exception => e
+      @notifier.notify_exception(e, program)
+      raise e
+    end
+
+    def record_path(program)
+      Kaede.config.record_dir.join("#{program.tid}_#{program.pid}.ts")
+    end
+
+    def cache_path(program)
+      Kaede.config.cache_dir.join("#{program.tid}_#{program.pid}.cache.ts")
+    end
+
+    def cache_ass_path(program)
+      Kaede.config.cache_dir.join("#{program.tid}_#{program.pid}.raw.ass")
+    end
+
+    def cabinet_path(program)
+      Kaede.config.cabinet_dir.join("#{program.formatted_fname}.ts")
+    end
+
+    def cabinet_ass_path(program)
+      Kaede.config.cabinet_dir.join("#{program.formatted_fname}.raw.ass")
+    end
+
+    def do_record(program)
+      spawn_recpt1(program)
+      spawn_tail(program)
+      spawn_b25(program)
+      spawn_ass(program)
+      spawn_repeater
+      wait_recpt1
+      finalize
+    end
+
+    def spawn_recpt1(program)
+      path = record_path(program)
+      path.open('w') {}
+      @recpt1_pid = spawn(Kaede.config.recpt1.to_s, program.channel_for_recorder.to_s, calculate_duration(program).to_s, path.to_s)
+    end
+
+    def calculate_duration(program)
+      duration = (program.end_time - program.start_time).to_i - 10
+      end_datetime = program.end_time.to_datetime
+      if end_datetime.sunday? && end_datetime.hour == 22 && end_datetime.min == 27
+        # For MX
+        duration += 3 * 60
+      elsif program.channel_name =~ /NHK/
+        # For NHK
+        duration += 25
+      end
+      duration
+    end
+
+    def spawn_tail(program)
+      @tail_pipe_r, @tail_pipe_w = IO.pipe
+      @tail_pid = spawn('tail', '-f', record_path(program).to_s, out: @tail_pipe_w)
+      @tail_pipe_w.close
+    end
+
+    def spawn_b25(program)
+      @b25_pipe_r, @b25_pipe_w = IO.pipe
+      @b25_pid = spawn(Kaede.config.b25.to_s, '-v0', '-s1', '-m1', '/dev/stdin', cache_path(program).to_s, in: @b25_pipe_r)
+      @b25_pipe_r.close
+    end
+
+    def spawn_ass(program)
+      @ass_pipe_r, @ass_pipe_w = IO.pipe
+      @ass_pid = spawn(Kaede.config.assdumper.to_s, '/dev/stdin', in: @ass_pipe_r, out: cache_ass_path(program).to_s)
+      @ass_pipe_r.close
+    end
+
+    BUFSIZ = 188 * 16
+
+    def spawn_repeater
+      @repeater_thread = Thread.start do
+        while buf = @tail_pipe_r.read(BUFSIZ)
+          @b25_pipe_w.write(buf)
+          @ass_pipe_w.write(buf)
+        end
+        @tail_pipe_r.close
+        @b25_pipe_w.close
+        @ass_pipe_w.close
+      end
+    end
+
+    def wait_recpt1
+      Process.waitpid(@recpt1_pid)
+    end
+
+    def finalize
+      Process.kill(:INT, @tail_pid)
+      Process.waitpid(@tail_pid)
+      @repeater_thread.join
+      Process.waitpid(@b25_pid)
+      Process.waitpid(@ass_pid)
+    end
+
+    def before_record(program)
+      @notifier.notify_before_record(program)
+    end
+
+    def after_record(program)
+      @notifier.notify_after_record(program)
+      move_ass_to_cabinet(program)
+      clean_ts(program)
+      enqueue_to_redis(program)
+      FileUtils.rm(cache_path(program).to_s)
+    end
+
+    def move_ass_to_cabinet(program)
+      ass_path = cache_ass_path(program)
+      if ass_path.size == 0
+        ass_path.unlink
+      else
+        FileUtils.mv(ass_path.to_s, cabinet_ass_path(program).to_s)
+      end
+    end
+
+    def clean_ts(program)
+      unless system(Kaede.config.clean_ts.to_s, cache_path(program).to_s, cabinet_path(program).to_s)
+        raise "clean-ts failure: #{program.formatted_fname}"
+      end
+    end
+
+    def enqueue_to_redis(program)
+      Kaede.config.redis.rpush(Kaede.config.redis_queue, program.formatted_fname)
+    end
+  end
+end