sleeproom 0.4.3 → 0.9.0.pre1

data/lib/sleeproom/record/tasks.rb

@@ -1,69 +1,71 @@
 # frozen_string_literal: true
+
 require "terminal-table"
 
 module SleepRoom
   module Record
     class Tasks
       # @return [void]
-      def self.start
-        Async do |_task|
-          count = 0
-          write_status = WriteStatus.new
-          SleepRoom.reload_config
-          if SleepRoom.running?
-            SleepRoom.error("PID #{SleepRoom.load_pid} Process is already running.")
-            exit
-          else
-            SleepRoom.write_config_file(:status, [])
-          end
-          SleepRoom.create_pid(Process.pid)
-          lists = SleepRoom.load_config(:record)
-          lists.each do |group, list|
-            SleepRoom.info("Empty list.") if list.empty?
-            list.each do |room|
-              record = SleepRoom::Record::Showroom.new(room: room["room"], group: group, queue: write_status)
-              record.record
-              count += 1
+      def self.start(verbose: false)
+        Async do |task|
+          begin
+            running_task_count = 0
+            write_status = WriteStatus.new
+            write_status.run
+            if SleepRoom.running?
+              SleepRoom.error("PID #{SleepRoom.load_pid} Process is already running.")
+              exit
+            else
+              SleepRoom.write_config_file(:status, [])
             end
-          rescue 
-            SleepRoom.error("Cannot parse Recording list.")
+            SleepRoom.create_pid(Process.pid)
+            lists = SleepRoom.load_config(:record)
+            lists.each do |group, list|
+              begin
+                SleepRoom.info("Empty list.") if list.empty?
+                list.each do |room|
+                  Async do
+                    running_task_count += 1
+                    record = SleepRoom::Record::Showroom.new(room: room["room"], group: group, queue: write_status)
+                    record.record
+                  end
+                end
+              rescue StandardError
+                SleepRoom.error("Cannot parse Recording list.")
+              end
+            end
+            SleepRoom.info("共启动 #{running_task_count} 个任务.")
+            if configatron.web.use
+              Async do
+                host = configatron.web.server.to_s
+                port = configatron.web.port.to_i
+                Rack::Handler.get(:falcon).run(Web::App, Host: host, Port: port)
+                SleepRoom.info("Web server running. http://#{host}:#{port}/")
+              end
+            end
+            task.children.each(&:wait)
+          rescue StandardError => e
+            puts e.full_message
           end
-          write_status.run
-          SleepRoom.info("共启动 #{count} 个任务.")
-          wait
-        rescue => e
-          puts e.full_message
         end
-      rescue Exception
+      rescue Exception => e
+        puts e.full_message if verbose
         SleepRoom.create_pid(nil) unless SleepRoom.running?
         puts "Exit..."
       end
 
       # @return [void]
       def self.stop
-        SleepRoom.reload_config
         raise "未实现"
       end
 
       # @return [void]
       def self.status
         Async do
-          SleepRoom.reload_config
-          status = SleepRoom.load_status
+          status = SleepRoom.load_status.sort_by { |hash| hash[:group] }
           pid = SleepRoom.load_config(:pid)
           if !SleepRoom.running?(pid) || status.empty? || pid.nil?
-            lists = SleepRoom.load_config(:record)
             SleepRoom.info("No tasks running.")
-            lists.each do |group, list|
-              next if list.empty?
-              rows = []
-              title = group
-              headings = list[0].keys
-              list.each do |hash|
-                rows.push(hash.values)
-              end
-              puts Terminal::Table.new(title: "[Recording list] Group: #{title}",:rows => rows, headings: headings)
-            end
           else
             rows = []
             headings = status[0].keys
@@ -71,7 +73,7 @@ module SleepRoom
               rows.push(
                 hash.values.map do |s|
                   if s.is_a?(Hash)
-                    "#{(s[:last_ack].is_a?(Time) ? "[ACK]" + s[:last_ack].strftime("%H:%M:%S").to_s : "nil")}"
+                    ((s[:last_ack].is_a?(Time) ? "[ACK]" + s[:last_ack].strftime("%H:%M:%S").to_s : "nil")).to_s
                   elsif s.is_a?(Time)
                     s.strftime("%H:%M:%S")
                   else
@@ -80,18 +82,34 @@ module SleepRoom
                 end
               )
             end
-            puts Terminal::Table.new(title: "Status [PID #{pid}] (#{status.count})",:rows => rows, headings: headings)
+            puts Terminal::Table.new(title: "Status [PID #{pid}] (#{status.count})", rows: rows, headings: headings)
           end
         end
       end
 
+      def self.lists
+        lists = SleepRoom.load_config(:record)
+        puts "[Record list]"
+        lists.each do |group, list|
+          next if list.empty?
+
+          rows = []
+          title = group
+          headings = list[0].keys
+          list.each do |hash|
+            rows.push(hash.values)
+          end
+          puts Terminal::Table.new(title: title, rows: rows, headings: headings)
+        end
+      end
+
       def self.add(room, group)
         Async do
           group = "default" if group.empty?
           old_record = SleepRoom.load_config(:record)
           name = API::RoomAPI.new(room).room_name
-          input_record = {"room" => room, "name" => name}
-          if !old_record[group].nil? && new_record = old_record[group].find{|h| h = input_record if h["room"] == room}
+          input_record = { "room" => room, "name" => name }
+          if !old_record[group].nil? && old_record[group].find { |h| h = input_record if h["room"] == room }
             SleepRoom.error("Room #{room} already exists.")
           else
             old_record[group] = [] if old_record[group].nil?
@@ -105,19 +123,10 @@ module SleepRoom
 
       def self.remove(room)
         old_record = SleepRoom.load_config(:record)
-        new_record = old_record.each {|k, v| v.delete_if { |h| h["room"] == room }}
+        new_record = old_record.each { |_k, v| v.delete_if { |h| h["room"] == room } }
         SleepRoom.write_config_file(:record, new_record)
         SleepRoom.info("Remove success.")
       end
-
-      private
-      def self.wait
-        Async do |task|
-          while true
-            task.sleep 1
-          end
-        end
-      end
     end
   end
 end

data/lib/sleeproom/record/web/app.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "roda"
+module SleepRoom
+  module Web
+    class App < Roda
+      plugin :default_headers,
+             "Content-Type" => "application/json",
+             "X-Frame-Options" => "deny",
+             "X-Content-Type-Options" => "nosniff",
+             "X-XSS-Protection" => "1; mode=block"
+      plugin :content_security_policy do |csp|
+        csp.default_src :none
+        csp.style_src :self
+        csp.form_action :self
+        csp.script_src :self
+        csp.connect_src :self
+        csp.base_uri :none
+        csp.frame_ancestors :none
+      end
+      plugin :public
+      plugin :multi_route
+      plugin :not_found do
+      end
+      plugin :error_handler do |e|
+        $stderr.print "#{e.class}: #{e.message}\n"
+        warn e.backtrace
+        next exception_page(e, assets: true) if ENV["RACK_ENV"] == "development"
+      end
+
+      route "status" do |r|
+        SleepRoom.load_status.sort_by { |hash| hash[:group] }.to_json
+      end
+
+      route "lists" do |r|
+        r.get do
+          SleepRoom.load_config(:record).to_json
+        end
+
+        r.post do
+        end
+      end
+      route do |r|
+        r.public
+        r.multi_route
+
+        r.root do
+          "SleepRoom Web API"
+        end
+      end
+    end
+  end
+end

data/lib/sleeproom/record/websocket.rb

@@ -1,86 +1,101 @@
+# frozen_string_literal: true
+
 require "sleeproom/async/websocket"
 require "async/http/endpoint"
 require "async/websocket/client"
 require "json"
 
 module SleepRoom
-    module Record
-        class WebSocket
-          attr_accessor :queue
-          def initialize(room:, broadcast_key:, url:)
-            @room = room
-            @url = "wss://" + url
-            @broadcast_key = broadcast_key
-            @running = false
-            @queue = Async::Queue.new
-          end
+  module Record
+    class WebSocket
+      attr_accessor :last_ack
+      def initialize(room:, broadcast_key:, url:)
+        @room = room
+        @url = "wss://" + url
+        @broadcast_key = broadcast_key
+        @running = false
+        @last_ack = nil
+      end
 
-          def connect(task: Async::Task.current)
-            url = @url
-            endpoint = Async::HTTP::Endpoint.parse(url)
-              Async::WebSocket::Client.connect(endpoint, handler: WebSocketConnection) do |connection|
-                @connection = connection
-                @running = true
-                connection.write("SUB\t#{@broadcast_key}")
+      def connect(task: Async::Task.current)
+        url = @url
+        endpoint = Async::HTTP::Endpoint.parse(url)
+        Async::WebSocket::Client.connect(endpoint, handler: WebSocketConnection) do |connection|
+          begin
+            @connection = connection
+            @running = true
+            connection.write("SUB\t#{@broadcast_key}")
+            connection.flush
+            log("Connect to websocket server.")
+            yield :status, { event: :connect, time: Time.now }
+
+            ping_task = task.async do |sub|
+              while @running
+                sub.sleep 60
+                connection.write("PING\tshowroom")
                 connection.flush
-                log("Connect to websocket server.")
-                @queue.enqueue({event: :connect, time: Time.now})
-                
-                ping_task = task.async do |sub|
-                  while @running
-                    sub.sleep 60
-                    @queue.enqueue({event: :ping, time: Time.now})
-                    connection.write("PING\tshowroom")
-                    connection.flush
-                  end
-                end
+              end
+            end
 
-                status_task = task.async do |sub|
-                  while true
-                    sub.sleep 1
-                    if @running == false
-                      connection.close
-                    end
-                  end
-                end
+            status_task = task.async do |sub|
+              loop do
+                sub.sleep 1
+                connection.close if @running == false
+              end
+            end
 
-                while message = connection.read
-                  if message == "ACK\tshowroom"
-                    @queue.enqueue({event: :ack, time: Time.now}) if message == "ACK\tshowroom"
-                  end
-                  if message.start_with?("MSG")
-                    begin
-                      yield JSON.parse(message.split("\t")[2])
-                    rescue => e
-                      SleepRoom.error(e.message)
-                    end
+            reconnect_task = task.async do |t|
+              loop do
+                t.sleep 10
+                if !@last_ack.nil? && Time.now.to_i - @last_ack.to_i > 65
+                  begin
+                    yield :status, { event: :close, time: Time.now }
+                    connection.close
+                  rescue
                   end
                 end
+              end
+            end
+            while message = connection.read
+              if message == "ACK\tshowroom"
+                @last_ack = Time.now
+                yield :status, { event: :ack, time: Time.now } if message == "ACK\tshowroom"
+              end
+              next unless message.start_with?("MSG")
+
+              begin
+                yield :websocket, JSON.parse(message.split("\t")[2])
               rescue => e
                 SleepRoom.error(e.message)
-              ensure
-                ping_task&.stop
-                connection.close
-                log("WebSocket closed.")
               end
+            end
+          rescue => e
+            yield :status, { event: :error, error: e }
+            SleepRoom.error(e.message)
+          ensure
+            ping_task&.stop
+            status_task&.stop
+            connection.close
+            reconnect_task&.stop
+            log("WebSocket closed.")
           end
-          
-          def running?
-            @running
-          end
+        end
+      end
 
-          def running=(bool)
-            @running = bool
-          end
+      def running?
+        @running
+      end
 
-          def stop
-            @running = false
-            @connection.close
-          end
+      attr_writer :running
 
-          def log(str)
-            SleepRoom.info("[#{@room}] #{str}")
-          end
+      def stop
+        @running = false
+        @connection.close
+      end
+
+      def log(str)
+        SleepRoom.info("[#{@room}] #{str}")
       end
-    end
-end
+  end
+  end
+end

data/lib/sleeproom/record/write_status.rb

@@ -15,9 +15,11 @@ module SleepRoom
             status[:update] = Time.now
             old_status = SleepRoom.load_config(:status)
             room = status[:room]
-            if old_status.find { |h| h[:room] == room }
+            if tmp_status = old_status.find { |h| h[:room] == room }
               new_status = old_status.delete_if { |h| h[:room] == room }
-              new_status.push(status)
+              unless tmp_status[:status] == :downloading && status[:status] == :waiting
+                new_status.push(tmp_status.merge!(status))
+              end
             else
               new_status = old_status.push(status)
             end
@@ -31,6 +33,31 @@ module SleepRoom
           @queue.enqueue(status)
         end
       end
+
+      def downloading(room:, url:, pid:, start_time:)
+        add(
+          {
+            room: room,
+            live: true,
+            status: :downloading,
+            streaming_url: url,
+            pid: pid,
+            start_time: start_time
+          }
+        )
+      end
+
+      def waiting(room:, group:, room_name:)
+        add(
+          {
+            room: room,
+            live: false,
+            group: group,
+            name: room_name,
+            status: :waiting,
+          }
+        )
+      end
     end
   end
 end

data/lib/sleeproom/utils.rb

@@ -3,6 +3,7 @@
 require "configatron"
 require "colorize"
 require "fileutils"
+require "tmpdir"
 require "yaml"
 require "logger"
 
@@ -64,6 +65,7 @@ module SleepRoom
   def self.create_config_file(config, settings)
     path = config_path(config)
     return false if File.exist?(path)
+
     mkdir(File.dirname(path)) unless Dir.exist?(File.dirname(path))
     write_config_file(config, settings)
   end
@@ -105,7 +107,7 @@ module SleepRoom
       default_save_name: "%ROOMNAME%-%TIME%.ts",
       minyami: {
         threads: 8,
-        retries: 999,
+        retries: 999
       },
       logger: {
         console: true,
@@ -122,9 +124,9 @@ module SleepRoom
     mkdir(config_dir) unless Dir.exist?(config_dir)
 
     mkdir("#{config_dir}/tmp") unless Dir.exist?("#{config_dir}/tmp")
-    
+
     init_base
-    
+
     record = {
       "default" => []
     }
@@ -150,6 +152,7 @@ module SleepRoom
   def self.settings
     configatron
   end
+
   def self.load_status
     SleepRoom.load_config(:status)
   rescue Error
@@ -164,11 +167,11 @@ module SleepRoom
     retry
   end
 
-  def self.running?(pid=nil)
+  def self.running?(pid = nil)
     pid = SleepRoom.load_config(:pid) if pid.nil?
     Process.kill(0, pid)
     true
-  rescue
+  rescue StandardError
     false
   end
 
@@ -183,7 +186,7 @@ module SleepRoom
     SleepRoom.create_config_file(:status, status)
   end
 
-  def self.create_record(record = {default: []})
+  def self.create_record(record = { default: [] })
     SleepRoom.create_config_file(:record, record)
   end
 
@@ -192,6 +195,34 @@ module SleepRoom
     SleepRoom.write_config_file(:pid, pid)
   end
   
+  def self.find_tmp_directory(output, call_time)
+    regex = /Proccessing (.*) finished./
+    output = "#{configatron.save_path}/#{output}"
+    log = "#{output}.out"
+    if media_name = File.readlines(log).select { |line| line =~ regex }.last.match(regex)[1]
+      directories = Dir["#{Dir.tmpdir}/minyami_#{call_time.to_i / 10}*"]
+      directories.each do |path| 
+        if Dir.glob("#{path}/*.ts").select{ |e| e.include?(media_name)}
+          next unless Dir.glob("#{path}/*.ts").last.include?(media_name)
+          
+          return path
+        end
+      end
+    end
+    return false
+  rescue => e
+    puts e.full_message
+    SleepRoom.error("寻找失败.")
+  end
+
+  def self.move_ts_to_archive(tmp, path, name)
+    FileUtils.cp_r(tmp, path)
+    FileUtils.mv(File.join(path, File.basename(tmp)), File.join(path, name))
+  rescue => e
+    puts e.full_message
+    SleepRoom.error("复制失败.")
+  end
+
   # @param string [String]
   # @return [nil]
   def self.info(string)