sleeproom 0.4.0 → 0.9.0.beta3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8b882f789e21adccfa42fdb69e4c103b6397421b7ba688f2f2465d3ba874be1
-  data.tar.gz: 51436fb96ee7f78de6e8e38541a260a5361bd4add38f0896f216728fa6ed3b03
+  metadata.gz: 3845e3c4fe71e788a6a58fdccdeafdf54df9a076970e603d255221f9a9eb485d
+  data.tar.gz: 5bb98e697e5b39f8d2a7c77e8b383dfcc68c76d342f9aa9a062cdb1908567bc4
 SHA512:
-  metadata.gz: c697893e07f46d16341ed3a6008c9b4fe304f7b76c3c8c3c6105a3c3c136d46daeade8530696eed0fe806989bca7e60acac10edb4eeb0e2fcf6e5ad312c60c6f
-  data.tar.gz: 0f5f7ae15517f8281ce44e3d8c0536b235436cf44fcfd9833c3f61b60a0cf82dd128788812a7185f4de82c8e3592fb5d11ca65edef58dc8b33b0fe4474e72ee6
+  metadata.gz: 10225f5c2f860a9c0862962f0e0e35ed8bd3ceb4d630d7cfc72dd98d388643dea785bab30448b2003c1019dbc3bcb708615ce63cd296fbff549c2d7c2a76d5d6
+  data.tar.gz: 638388a6ab62c5db454155bdf8d21aebd6f1fdd562ea0b807add10c4759008ab2f09e96f535990ca506ffa5ccfdbcccdde7509ef22434b94d660ee0d584322cd

data/.gitignore

@@ -11,5 +11,7 @@
 # rspec failure tracking
 .rspec_status
 
+Gemfile.lock
+
 # config
 /config/base.yml

data/Gemfile

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
 # Specify your gem's dependencies in sleeproom.gemspec
 gemspec
 
-gem "rake", "~> 12.0"
+gem "rake", "~> 13.0"
 gem "rspec", "~> 3.0"
-gem "rubocop", "~> 0.79.0"
 gem "rubocop-github"
 gem "rubocop-performance", require: false

data/README.md

@@ -16,7 +16,6 @@
 ## TODO
 * [ ] 代理支持
 * [ ] Web GUI
-* [ ] 日志保存
 
 ## Service example
 ```

data/Rakefile

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: :spec

data/bin/sleeproom

@@ -3,5 +3,4 @@
 
 require "sleeproom/cli"
 
-cli = SleepRoom::CLI.new(ARGV)
-cli.run
+SleepRoom::CLI.new(ARGV)

data/lib/sleeproom/async/websocket.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "async/websocket/connection"
 class WebSocketConnection < Async::WebSocket::Connection
   def read
@@ -5,16 +7,16 @@ class WebSocketConnection < Async::WebSocket::Connection
       parse(buffer)
     end
   end
-  
+
   def write(object)
     super(dump(object))
   end
-  
+
   def parse(buffer)
-    return buffer
+    buffer
   end
-  
+
   def dump(object)
-    return object
+    object
   end
-end
+end

data/lib/sleeproom/cli.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "ruby-next"
 require "optparse"
 require "yaml"
 require "sleeproom/record"
@@ -8,17 +9,25 @@ module SleepRoom
   class CLI
     # @param argv [Array]
     def initialize(argv)
+      SleepRoom.reload_config
       @options = {}
+      begin
+        minyami = `minyami --version`
+        status = $?
+      rescue => e
+        SleepRoom.warning("无法调用 Minyami: #{e.message}")
+      end
       build
-      unless argv.empty?
+      if argv.empty? == false
         @parser.parse!(argv)
         action = argv.shift
-        if action == "status"
+        case action
+        when "status"
           SleepRoom::Record::Tasks.status
-        elsif action == "start"
-          SleepRoom::Record::Tasks.start
-        elsif action == "exit"
-          SleepRoom::Record::Tasks.stop
+        when "start"
+          SleepRoom::Record::Tasks.start(**@options)
+        when "lists"
+          SleepRoom::Record::Tasks.lists
         end
         exit(0)
       else
@@ -27,46 +36,49 @@ module SleepRoom
       end
     end
 
-    # @return [void]
-    def run
-      SleepRoom::Record::Tasks.start
-    end
-
     # @return [void]
     def build
       @parser = OptionParser.new do |opt|
         opt.version = "SleepRoom / #{SleepRoom::VERSION}"
-        opt.banner = "#{opt.version}"
+        opt.banner = opt.version.to_s
         opt.banner += "\nUsage: sleeproom [Options]\n\n"
 
         opt.banner += "Action:\n"
         opt.banner += "status".rjust(10)
         opt.banner += "显示任务状态".rjust(33)
         opt.banner += "\n"
+        opt.banner += "lists".rjust(9)
+        opt.banner += "显示录制列表".rjust(34)
+        opt.banner += "\n"
         opt.banner += "exit".rjust(8)
         opt.banner += "关闭任务队列".rjust(35)
         opt.banner += "\n\nCommands:\n"
 
-        opt.on("-a ROOM, NAME", "--add ROOM, GROUP", Array, "添加到监视列表") do |room|
+        opt.on("-a ROOM, NAME", "--add ROOM, GROUP", Array, "添加房间到监视列表") do |room|
           SleepRoom::Record::Tasks.add(room[0].to_s, room[1].to_s)
         end
 
-        opt.on("-r", "--remove [ROOM]", "从监视列表移除") do |room|
+        opt.on("-r", "--remove [ROOM]", "从监视列表移除房间") do |room|
           SleepRoom::Record::Tasks.remove(room)
         end
 
         opt.on("-d", "--download [ROOM]", "录制指定房间") do |room|
-          raise Error.new("房间名不能为空") if room.nil?
+          raise Error, "房间名不能为空" if room.nil?
+
+          room = room.match(%r{https://www.showroom-live.com/(.*)})[1] if room.match?("https://www.showroom-live.com/")
           write_status = SleepRoom::Record::WriteStatus.new
-          record = SleepRoom::Record::Showroom.new(room: room, group: "download", queue: write_status)
-          record.record
+          Async do
+            record = SleepRoom::Record::Showroom.new(room: room, group: "download", queue: write_status)
+            record.record
+          end
         end
 
-        opt.on("-v", "--verbose", "Print log") do
+        opt.on("--verbose", "DEBUG") do
+          ENV["SR_DEBUG"] = "DEBUG"
           @options[:verbose] = true
         end
-        
-        opt.on_tail("--version", "Print version") do
+
+        opt.on_tail("-v", "--version", "Print version") do
           STDOUT.puts(opt.version)
         end
 

data/lib/sleeproom/record.rb

@@ -8,39 +8,41 @@ require "sleeproom/record/record"
 require "sleeproom/record/tasks"
 require "sleeproom/record/websocket"
 require "sleeproom/record/api/api"
+require "sleeproom/record/plugins"
 require "async"
 require "shellwords"
 module SleepRoom
   module Record
     # Okite!!!
     # @param url [String]
-    # @return [Boolean]
-    def self.call_minyami(url:, is_live: true, threads: configatron.minyami.threads, output:, retries: configatron.minyami.retries)
+    # @return [Integer]
+    def self.call_minyami(url:, is_live: true, threads: configatron.minyami.threads, output:, retries: configatron.minyami.retries, no_merge: configatron.minyami.no_merge)
       command = "minyami -d #{Shellwords.escape(url)}"
       command += " --retries #{retries.to_i}" if retries
       command += " --threads #{threads.to_i}" if threads
       command += " --live" if is_live
+      command += " --nomerge" if no_merge
       output = File.join(configatron.save_path, output)
       command += " --output #{Shellwords.escape(output)}" if output
       download_dir_check(output)
       pid = exec_command(command, output)
-      return pid
+      pid
     end
 
     # @param command [String]
-    # @return [Boolean]
+    # @return [Integer]
     def self.exec_command(command, output)
       SleepRoom.info("Call command: #{command}")
       SleepRoom.info("STDOUT: #{output}.out , STDERR: #{output}.err")
       pid = spawn(command, out: "#{output}.out", err: "#{output}.err")
       SleepRoom.info("PID: #{pid}")
       Process.detach(pid)
-      return pid
+      pid
     end
 
     def self.download_dir_check(output)
       dir = File.dirname(output)
-      if !Dir.exist?(dir)
+      unless Dir.exist?(dir)
         SleepRoom.info("#{dir} does not exist, creating...")
         SleepRoom.mkdir(dir)
       end

data/lib/sleeproom/record/api/api.rb

@@ -11,15 +11,11 @@ module SleepRoom
     module API
       class Error < StandardError; end
       class NotFoundError < Error; end
-      ROOM_URL = "https://www.showroom-live.com"
-      ROOM_API = "https://www.showroom-live.com/api/room/status"
-      STREAMING_API = "https://www.showroom-live.com/api/live/streaming_url"
-
       USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36"
 
-      def self.get(url)
-        Async do
-          http = Faraday.get(url, nil, {"User-Agent": USER_AGENT})
+      def self.get(url, task: Async::Task.current)
+        task.async do
+          http = Faraday.get(url, nil, { "User-Agent": USER_AGENT })
           if http.status == 200
             @json = JSON.parse(http.body)
           elsif http.status == 404

data/lib/sleeproom/record/api/room.rb

@@ -4,11 +4,12 @@ module SleepRoom
   module Record
     module API
       class Room
+        ROOM_URL = "https://www.showroom-live.com"
         def initialize(room_name)
           @url = ROOM_URL + "/" + room_name
         end
 
-        def get(task: Async::Task.current)
+        def get
           @json = API.get(@url).wait
         end
       end

data/lib/sleeproom/record/api/room_api.rb

@@ -4,13 +4,14 @@ module SleepRoom
   module Record
     module API
       class RoomAPI
+        ROOM_API = "https://www.showroom-live.com/api/room/status"
         def initialize(room_url_key)
           @url = ROOM_API + "?room_url_key=" + room_url_key
           @json = nil
           get
         end
 
-        def get(task: Async::Task.current)
+        def get
           @json = API.get(@url).wait
         end
 

data/lib/sleeproom/record/api/streaming_api.rb

@@ -4,21 +4,22 @@ module SleepRoom
   module Record
     module API
       class StreamingAPI
+        STREAMING_API = "https://www.showroom-live.com/api/live/streaming_url"
         def initialize(room_id)
           @url = STREAMING_API + "?room_id=" + room_id.to_s + "&ignore_low_stream=1"
           @json = nil
           get
         end
 
-        def get(task: Async::Task.current)
+        def get
           @json = API.get(@url).wait
         end
 
         def streaming_url
           if @json["streaming_url_list"].nil?
-            raise Error.new("streaming url is null.")
+            raise Error, "streaming url is null."
           else
-            @json["streaming_url_list"].sort_by{|hash| -hash["quality"]}.first["url"]
+            @json["streaming_url_list"].min_by { |hash| -hash["quality"] }["url"]
           end
         end
       end

data/lib/sleeproom/record/plugins.rb

@@ -0,0 +1,9 @@
+require 'dry/system/container'
+
+module SleepRoom
+  module Record
+    class Plugins
+      extend Dry::Container::Mixin
+    end
+  end
+end

data/lib/sleeproom/record/plugins/youtube/upload.rb

@@ -0,0 +1 @@
+# Youtube Uploader

data/lib/sleeproom/record/record.rb

@@ -1,148 +1,111 @@
 # frozen_string_literal: true
+
 require "sleeproom/record/write_status"
 
 module SleepRoom
   module Record
+    # showroom-live.com
     class Showroom
-      SITE = "showroom"
+      # Showroom Downloader
+      # @param room [String]
+      # @param group [String]
+      # @param queue [WriteStatus]
       def initialize(room:, group: "default", queue:)
         @room = room
         @group = group
-        @queue = queue
+        @status = queue
         @running = false
-        @downlaoding = false
-        @reconnection = false
+        @downloading = false
+        set_room_info
       end
 
-      # @param user [String]
-      # @return [Boolean]
-      def record(reconnection: false)
-        room = @room
-        Async do |task|
-          set_room_info
-          task.async do |t|
-            while @is_live
-              if status = SleepRoom.load_config(:status).find{|hash| hash[:room] == room}
-                if !status[:pid].nil?
-                  break if SleepRoom.running?(status[:pid]) == false
-                else
-                  break
-                end
-              else
-                break
-              end
-              t.sleep 60
-            end
-          end.wait
-          if @is_live
-            start_time = Time.now
-            log("Live broadcast.")
-            streaming_url = parse_streaming_url
-            output = build_output
-            pid = SleepRoom::Record.call_minyami(url: streaming_url, output: output)
-            downloading(streaming_url, pid, start_time)
-            record
-          else
-            log("Status: Stop.")
-            waiting_live(ws: :init)
-            Async do |task|
-              while true
-                if @running == false && @reconnection == false
-                  start_websocket
-                elsif @reconnection == true
-                  set_room_info
-                  start_websocket
-                  @reconnection = false
-                end
-                task.sleep 10
-              end
-            end
-          end
-        rescue => e
-          add_error(e)
-          SleepRoom.error(e.full_message)
-          log("Retry...")
-          task.sleep 5
-          retry
+      # Record Room
+      def record
+        if @is_live
+          log("Status: broadcast.")
+          download_process if @downloading == false
+        else
+          update_status
+          log("Status: Stop.")
         end
+        start_websocket
+      rescue => e
+        error(e.full_message)
+        Async::Task.current.sleep 5
+        set_room_info
+        retry
       end
 
+      # Print log
+      # @param str [String]
       def log(str)
         SleepRoom.info("[#{@room}] #{str}")
       end
-      
+
+      def debug(str)
+        SleepRoom.debug("[#{@room}] #{str}")
+      end
+
+      # Print log
+      # @param str [String]
+      def error(str)
+        SleepRoom.error("[#{@room}] #{str}")
+      end
+
       private
-      def start_websocket()
-        Async do |task|
-          @running = true
-          log("Broadcast Key: #{@broadcast_key}")
-          waiting_live(ws: :init)
-          ws = WebSocket.new(room: @room, broadcast_key: @broadcast_key, url: @broadcast_host)
-          @ws = ws
-          # ws status
-          ws_task = task.async do |sub|
-            ws.running = true
-            ws.connect(task: sub) do |message|
-              case message["t"].to_i
-              when 101
-                log("Live stop.")
-                ws.running = false
-                @running = false
-                record
-              when 104
-                log("Live start.")
-                start_time = Time.now
-                streaming_url = parse_streaming_url
-                output = build_output
-                pid = SleepRoom::Record.call_minyami(url: streaming_url, output: output)
-                downloading(streaming_url, pid, start_time)
-                ws.running = false
-                @running = false
-                @reconnection = true
-              else
-                # other
-              end
-            end
-          rescue => e
-            SleepRoom.error("WS Stop.")
-            SleepRoom.error(e.full_message)
-            ws.running = false
-            @running = false
-            add_error(e)
-          end
 
-          Async do |task|
-            last_ack = nil
-            last_ping = nil
-            while @running && @downlaoding == false
-              queue = ws.queue.items
-              if !queue.empty?
-                queue.each do |event|
-                  case event[:event]
-                  when :ack
-                    last_ack = event[:time]
-                  when :ping
-                    last_ping = event[:ping]
-                  end
-                end
-              end
-              if !last_ack.nil? && Time.now.to_i - last_ack.to_i > 65
-                ws.running = false
-                @running = false
-                task.stop
-              end
-              waiting_live({last_ack: last_ack})
-              task.sleep 1
-            end
+      def open_handler
+      end
+
+      def message_handler(data)
+        case data["t"].to_i
+        when 101
+          log("Live stop.")
+          @is_live = false
+          set_room_info
+        when 104
+          log("Live start.")
+          download_process
+        end
+      end
+
+      def close_handler(error)
+        @running = false
+      end
+
+      def error_handler(error)
+        @running = false
+      end
+
+      def ping_handler
+      end
+
+      # Websocket connect
+      def start_websocket(task: Async::Task.current)
+        connection = task.async do |task|
+          while @running == false
+            log("Broadcast Key: #{@broadcast_key}")
+            @ws = WebSocket.new(
+              room: @room, 
+              broadcast_key: @broadcast_key,
+              url: @broadcast_host,
+              open_handler: method(:open_handler),
+              message_handler: method(:message_handler),
+              close_handler: method(:close_handler),
+              error_handler: method(:error_handler),
+              ping_handler: method(:ping_handler)
+            )
+            @ws.connect
           end
-          task.children.each(&:wait)
-        ensure
-          ws.running = false
-          @running = false
         end
+        task.children.each(&:wait)
+      ensure
+        log("Websocket task stop.")
+        connection&.stop
+        @running = false
       end
-      
-      def set_room_info
+
+      def set_room_info(task: Async::Task.current)
         api = API::RoomAPI.new(@room)
         @room_id = api.room_id
         @room_name = api.room_name
@@ -150,94 +113,103 @@ module SleepRoom
         @broadcast_host = api.broadcast_host
         @broadcast_key = api.broadcast_key
       rescue API::NotFoundError
-        SleepRoom.error("[#{@room}] The room does not exist.")
+        error("The room does not exist.")
         log("Task stopped.")
-        Async::Task.current.stop
+        task.stop
       rescue => e
-        SleepRoom.error(e.message)
-        log("[setRoomInfo] Retry...")
+        error(e.message)
+        log("Cannot parse room info.")
+        log("try again...")
+        task.sleep 5
         retry
       end
 
       def parse_streaming_url(task: Async::Task.current)
         api = API::StreamingAPI.new(@room_id)
-        streaming_url_list = api.streaming_url
+        api.streaming_url
       rescue => e
         SleepRoom.error(e.full_message)
-        log("[parseStreamingUrl] Retry...")
+        log("Unable to parse HLS url.")
+        task.sleep 1
         retry
       end
 
-      def build_output(task: Async::Task.current)
-        room = @room
-        group = @group
-        tmp_str = configatron.default_save_name
-        tmp_str = tmp_str.sub("\%TIME\%", Time.now.strftime("%Y-%m-%d-%H-%M-%S")) if tmp_str.include?("\%TIME\%")
-        tmp_str = tmp_str.sub("\%ROOMNAME\%", room) if tmp_str.include?("\%ROOMNAME\%")
-        File.join(group, room, "showroom", tmp_str)
-      end
-
-      def downloading(streaming_url, pid, start_time, task: Async::Task.current)
-      @downlaoding = true
-        @queue.add({
-          room: @room,
-          start_time: start_time,
-          name: @room_name,
-          group: @group,
-          live: true,
-          status: :downloading,
-          streaming_url: streaming_url,
-          download_pid: pid
-        })
+      # Downloader
+      def download_process(task: Async::Task.current)
+        completed = false
+        @downloading = true
+        log("Download start.")
+        streaming_url = parse_streaming_url
+        output = build_output
+        # Call time
+        call_time = Time.now
+        pid = SleepRoom::Record.call_minyami(url: streaming_url, output: output)
+        @status.downloading(room: @room, url: streaming_url, pid: pid, start_time: call_time, output: output)
+        log("Waiting for download process.")
+        # Status
         task.async do |t|
           loop do
-            live = API::RoomAPI.new(@room).live?
-            if !SleepRoom.running?(pid) && !live
-              log("Download complete.")
-              @downlaoding = false
-              @queue.add({
-                room: @room,
-                name: @room_name,
-                group: @group,
-                live: API::RoomAPI.new(@room).live?,
-                status: :complete,
-              })
+            if SleepRoom.running?(pid) && @is_live
+              # Downloading
+            elsif SleepRoom.running?(pid) && @is_live == false
+              # Live stopped, Minyami process running.
+              retries = 0
+              while retries < 3
+                set_room_info
+                break if @is_live == true
+
+                log("Waiting for latest status...")
+                task.sleep 5
+                retries += 1
+              end
+              completed = true if retries == 3 && @is_live == false
+            elsif (SleepRoom.running?(pid) == false && @is_live == false) || completed
+              # Live stopped, Minyami process stopped.
+              @status.add(room: @room, status: :completed, live: false)
+              log("Download completed.")
+              if configatron.minyami.no_merge
+                log("Find minyami temp files...")
+                tmp_path = SleepRoom.find_tmp_directory(output, call_time)
+                if tmp_path
+                  log("Temp files in #{tmp_path}.")
+                  save_path = File.dirname("#{configatron.save_path}/#{output}")
+                  dir_name = File.basename(output).sub(".ts", "")
+                  SleepRoom.move_ts_to_archive(tmp_path, save_path, dir_name)
+                  log("Save chunks to #{save_path}/#{dir_name}.")
+                else
+                  log("Can not find temp file")
+                end
+              end
+              @ws.close
+              @running = false
               break
-            elsif live && !SleepRoom.running?(pid)
-              log("Minyami crash.")
-              streaming_url = parse_streaming_url
-              output = build_output
-              pid = SleepRoom::Record.call_minyami(url: streaming_url, output: output)
-            elsif !live && SleepRoom.running?(pid)
-              log("Live stop.")
+            elsif SleepRoom.running?(pid) == false && @is_live == true
+              # Live broadcast, Minyami process stopped.
+              set_room_info
+              next if @is_live == false
+
+              log("Minyami stopped, Try to call Minyami again.")
+              download_process
             end
-            t.sleep 120
-          rescue Faraday::ConnectionFailed
-            log("Network error.")
-            retry
+            t.sleep 1
           end
-        end.wait
-      end
-
-      def add_error(error)
-        @queue.add({
-          room: @room,
-          name: @room_name,
-          group: @group,
-          status: :retry,
-          error: error.message
-        })
-      end
-
-      def waiting_live(status)
-        @queue.add({
-          room: @room,
-          live: false,
-          group: @group,
-          name: @room_name,
-          status: :waiting,
-          ws: status
-        })
+        end
+      ensure
+        @downloading = false
+      end
+
+      # @return [String]
+      def build_output
+        room = @room
+        group = @group
+        tmp_str = configatron.default_save_name
+        tmp_str = tmp_str.sub("\%TIME\%", Time.now.strftime("%Y-%m-%d-%H-%M-%S")) if tmp_str.include?("\%TIME\%")
+        tmp_str = tmp_str.sub("\%ROOMNAME\%", room) if tmp_str.include?("\%ROOMNAME\%")
+        File.join(group, room, tmp_str)
+      end
+
+      def update_status
+        @status.waiting(room: @room, group: @group, room_name: @room_name, key: @broadcast_key)
       end
     end
   end