sleeproom 0.1.1

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module SleepRoom
+  module Record
+    module API
+      class RoomAPI
+        def initialize(room_url_key)
+          @url = ROOM_API + "?room_url_key=" + room_url_key
+          @json = nil
+          get
+        end
+
+        def get(task: Async::Task.current)
+          @json = API.get(@url).wait
+        end
+
+        def live?
+          @json["is_live"]
+        end
+
+        def broadcast_key
+          @json["broadcast_key"].to_s
+        end
+
+        def broadcast_host
+          @json["broadcast_host"].to_s
+        end
+
+        def room_id
+          @json["room_id"]
+        end
+
+        def room_name
+          @json["room_name"]
+        end
+      end
+    end
+  end
+  end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SleepRoom
+  module Record
+    module API
+      class StreamingAPI
+        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)
+          @json = API.get(@url).wait
+        end
+
+        def streaming_url
+          @json["streaming_url_list"].sort_by{|hash| -hash["quality"]}.first["url"]
+        end
+      end
+    end
+  end
+  end

data/lib/sleeproom/record/record.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+require "sleeproom/record/write_status"
+
+module SleepRoom
+  module Record
+    class Showroom
+      SITE = "showroom"
+      def initialize(room:, group: "default", queue:)
+        @room = room
+        @group = group
+        @queue = queue
+        @running = false
+        @downlaoding = false
+        @reconnection = false
+      end
+
+      # @param user [String]
+      # @return [Boolean]
+      def record(reconnection: false)
+        room = @room
+        Async do |task|
+          api = API::RoomAPI.new(room)
+          task.async do |t|
+            while api.live?
+              if status = SleepRoom.load_config(:status).find{|hash| hash[:room] == room}
+                if !status[:pid].nil?
+                  break if SleepRoom.running?(pid) == false
+                else
+                  break
+                end
+              else
+                break
+              end
+              t.sleep 60
+            end
+          end.wait
+          @room_id = api.room_id
+          @room_name = api.room_name
+          @is_live = api.live?
+          @broadcast_host = api.broadcast_host
+          @broadcast_key = api.broadcast_key
+          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
+                  api = API::RoomAPI.new(room)
+                  @room_id = api.room_id
+                  @room_name = api.room_name
+                  @is_live = api.live?
+                  @broadcast_host = api.broadcast_host
+                  @broadcast_key = api.broadcast_key
+                  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
+        end
+      end
+
+      def log(str)
+        SleepRoom.info("[#{@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|
+            while @running && @downlaoding == false
+              status = ws.status
+              if !status[:last_ack].nil? && Time.now.to_i - status[:last_ack].to_i > 65
+                ws.running = false
+                @running = false
+                task.stop
+              end
+              waiting_live(status)
+              task.sleep 30
+            end
+          end
+          task.children.each(&:wait)
+        ensure
+          ws.running = false
+          @running = false
+        end
+      end
+
+      def parse_streaming_url(task: Async::Task.current)
+        api = API::StreamingAPI.new(@room_id)
+        streaming_url_list = api.streaming_url
+      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
+        })
+        task.async do |t|
+          while true
+            if !SleepRoom.running?(pid) && !API::RoomAPI.new(@room).live?
+              log("Download complete.")
+              @downlaoding = false
+              @queue.add({
+                room: @room,
+                name: @room_name,
+                group: @group,
+                live: API::RoomAPI.new(@room).live?,
+                status: :complete,
+              })
+              break
+            end
+            t.sleep 60
+          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
+    end
+  end
+end

data/lib/sleeproom/record/tasks.rb

@@ -0,0 +1,123 @@
+# 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
+            end
+          rescue 
+            SleepRoom.error("Cannot parse Recording list.")
+          end
+          write_status.run
+          SleepRoom.info("共启动 #{count} 个任务.")
+          wait
+        rescue => e
+          puts e.full_message
+        end
+      rescue Exception
+        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
+          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
+            status.each do |hash|
+              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")}"
+                  elsif s.is_a?(Time)
+                    s.strftime("%H:%M:%S")
+                  else
+                    s.to_s
+                  end
+                end
+              )
+            end
+            puts Terminal::Table.new(title: "Status [PID #{pid}] (#{status.count})",:rows => rows, headings: headings)
+          end
+        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}
+            SleepRoom.error("Room #{room} already exists.")
+          else
+            old_record[group] = [] if old_record[group].nil?
+            old_record[group].push(input_record)
+            new_record = old_record
+            SleepRoom.write_config_file(:record, new_record)
+            SleepRoom.info("Added success.")
+          end
+        end
+      end
+
+      def self.remove(room)
+        old_record = SleepRoom.load_config(:record)
+        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

@@ -0,0 +1,91 @@
+require "sleeproom/async/websocket"
+require "async/http/endpoint"
+require "async/websocket/client"
+require "json"
+
+module SleepRoom
+    module Record
+        class WebSocket
+          def initialize(room:, broadcast_key:, url:)
+            @room = room
+            @url = "wss://" + url
+            @broadcast_key = broadcast_key
+            @running = false
+            @status = {}
+          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.")
+                @status[:last_update] = Time.now
+                
+                ping_task = task.async do |sub|
+                  while @running
+                    sub.sleep 60
+                    @status[:last_ping] = Time.now
+                    connection.write("PING\tshowroom")
+                    connection.flush
+                  end
+                end
+
+                status_task = task.async do |sub|
+                  while true
+                    sub.sleep 1
+                    if @running == false
+                      connection.close
+                    end
+                  end
+                end
+
+                while message = connection.read
+                  @status[:last_update]
+                  if message == "ACK\tshowroom"
+                    @status[:last_ack] = Time.now if message == "ACK\tshowroom"
+                  end
+                  if message.start_with?("MSG")
+                    @status[:last_msg] = Time.now
+                    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
+          end
+
+          def running=(bool)
+            @running = bool
+          end
+
+          def stop
+            @running = false
+            @connection.close
+          end
+
+          def status
+            @status
+          end
+
+          def log(str)
+            SleepRoom.info("[#{@room}] #{str}")
+          end
+      end
+    end
+end