sleeproom 0.4.0 → 0.9.0.beta3

data/lib/sleeproom/record/tasks.rb

@@ -1,69 +1,63 @@
 # 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} 个任务.")
+            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 +65,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 +74,40 @@ 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?
+          if group.empty?
+            if group_match = room.match(/(?<=[(（]).*?(?=[)）])/)
+              group = group_match[0]
+            else
+              group = "default"
+            end
+          end
           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 +121,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/websocket.rb

@@ -1,86 +1,92 @@
+# 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
+      def initialize(room:, broadcast_key:, url:, open_handler:, message_handler:, close_handler:, error_handler:, ping_handler:)
+        @room = room
+        @url = "wss://" + url
+        @broadcast_key = broadcast_key
+        @running = false
+        @endpoint = Async::HTTP::Endpoint.parse(@url)
+        @open_handler = open_handler
+        @message_handler = message_handler
+        @close_handler = close_handler
+        @error_handler = error_handler
+        @ping_handler = ping_handler
+      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}")
-                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
+      def connect(task: Async::Task.current)
+        websocket = Async::WebSocket::Client.connect(@endpoint, handler: WebSocketConnection) do |connection|
+          @connection = connection
+          @running = true
+          send("SUB\t#{@broadcast_key}")
 
-                status_task = task.async do |sub|
-                  while true
-                    sub.sleep 1
-                    if @running == false
-                      connection.close
-                    end
-                  end
-                end
+          log("Connect to websocket server.")
+          @open_handler.call
 
-                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
-                  end
-                end
-              rescue => e
-                SleepRoom.error(e.message)
-              ensure
-                ping_task&.stop
-                connection.close
-                log("WebSocket closed.")
-              end
-          end
-          
-          def running?
-            @running
+          ping = task.async do |task|
+            loop do
+              task.sleep 60
+              send("PING\tshowroom")
+            end
           end
 
-          def running=(bool)
-            @running = bool
-          end
+          while message = connection.read
+            debug("ACK: #{message}")
+            @ping_handler.call if message == "ACK\tshowroom"
 
-          def stop
-            @running = false
-            @connection.close
-          end
+            next unless message.start_with?("MSG")
 
-          def log(str)
-            SleepRoom.info("[#{@room}] #{str}")
+            begin
+              @message_handler.call(JSON.parse(message.split("\t")[2]))
+            rescue JSON::ParserError => e
+              @error_handler.call(e)
+              log(e.message)
+            end
           end
+        rescue => e
+          error "error"
+          @error_handler.call(e)
+          log(e.full_message)
+        ensure
+          ping&.stop
+          @close_handler.call(nil)
+          @running = false
+          log("WebSocket closed.")
+        end
+      end
+
+      def send(data)
+        debug("SEND: #{data}")
+        @connection.write(data)
+        @connection.flush
+      end
+
+      def running?
+        @running
+      end
+
+      def stop
+        @connection.close
+      end
+
+      def log(str)
+        SleepRoom.info("[#{@room}] #{str}")
+      end
+
+      def error(str)
+        SleepRoom.error("[#{@room}] #{str}")
+      end
+
+      def debug(str)
+        SleepRoom.debug("[#{@room}] #{str}")
       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,34 @@ module SleepRoom
           @queue.enqueue(status)
         end
       end
+
+      def downloading(room:, url:, pid:, start_time:, output:)
+        add(
+          {
+            room: room,
+            live: true,
+            status: :downloading,
+            streaming_url: url,
+            pid: pid,
+            start_time: start_time
+          }
+        )
+      end
+
+      def waiting(room:, group:, room_name:, key:)
+        add(
+          {
+            room: room,
+            live: false,
+            group: group,
+            name: room_name,
+            status: :waiting,
+            websocket: {
+              key: key
+            }
+          }
+        )
+      end
     end
   end
 end

data/lib/sleeproom/utils.rb

@@ -3,11 +3,17 @@
 require "configatron"
 require "colorize"
 require "fileutils"
+require "tmpdir"
 require "yaml"
 require "logger"
+require "dry/files"
 
 module SleepRoom
   class Error < StandardError; end
+  def self.files
+    Dry::Files.new
+  end
+  
   # @return [String]
   def self.root_path
     Dir.pwd
@@ -64,6 +70,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
@@ -83,15 +90,10 @@ module SleepRoom
 
   def self.init_base
     base = {
-      web: {
-        use: true,
-        server: "localhost",
-        port: 3000
-      },
       proxy: {
         use: false,
         server: "localhost",
-        port: 8080,
+        port: 1080,
         type: "socks5"
       },
       record: {
@@ -106,11 +108,12 @@ module SleepRoom
       minyami: {
         threads: 8,
         retries: 999,
+        no_merge: false,
       },
       logger: {
         console: true,
         file: {
-          use: true,
+          use: false,
           path: "#{sleeproom_dir}/log"
         }
       }
@@ -122,9 +125,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" => []
     }
@@ -142,13 +145,15 @@ module SleepRoom
     end
     true
   rescue Errno::ENOENT => e
-    error("Could not load file. \n#{e.message}")
+    info("Creating configuration...")
+    init_base
     false
   end
 
   def self.settings
     configatron
   end
+
   def self.load_status
     SleepRoom.load_config(:status)
   rescue Error
@@ -163,11 +168,11 @@ module SleepRoom
     retry
   end
 
-  def self.running?(pid=nil)
+  def self.running?(pid = nil)
     pid = SleepRoom.load_config(:pid) if pid.nil?
-    Process.getpgid(pid)
+    Process.kill(0, pid)
     true
-  rescue
+  rescue StandardError
     false
   end
 
@@ -182,7 +187,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
 
@@ -191,38 +196,81 @@ module SleepRoom
     SleepRoom.write_config_file(:pid, pid)
   end
   
+  def self.plugins
+    
+  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)
-    log(:info, "[INFO] #{string}".colorize(:white))
+    log(:info, string)
+  end
+
+  # @param string [String]
+  # @return [nil]
+  def self.debug(string)
+    log(:debug, string) if ENV["SR_DEBUG"]
   end
 
   # @param string [String]
   # @return [nil]
   def self.warning(string)
-    log(:warning, "[WARN] #{string}".colorize(:yellow))
+    log(:warning, string)
   end
 
   # @param string [String]
   # @return [nil]
   def self.error(string)
-    log(:error, "[ERROR] #{string}".colorize(:red))
+    log(:error, string)
   end
 
   def self.log(type, log)
-    case type
-    when :info
-      puts(log)
-    when :warning
-      warn(log)
-    when :error
-      puts(log)
+    if configatron.logger.console == true
+      case type
+      when :info
+        puts("[INFO] #{log}".colorize(:white))
+      when :warning
+        warn("[WARN] #{log}".colorize(:yellow))
+      when :error
+        puts("[ERROR] #{log}".colorize(:red))
+      when :debug
+        puts("[DEBUG] #{log}".colorize(:gray))
+      end
     end
     file_logger(type, log) if configatron.logger.file.use == true
   end
 
   def self.file_logger(type, log)
     path = configatron.logger.file.path
+    mkdir(File.dirname(path)) unless Dir.exist?(File.dirname(path))
     logger = Logger.new(path)
     case type
     when :info