miniradio_server 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: aaaf57cfdaba5f66a068447ec813636651ddc440000f09815658f9a42c539606
+  data.tar.gz: 05d5e7eb56654389f97e779c50376f778af460c93c1ba195f9c3998f6ca50f56
+SHA512:
+  metadata.gz: 6ce3d244968874b6a9810e13f0f2ffbeeb7d1a7cc76531ffefa71a3cbdbe6e03828861456386cf1a7e68e4e50321c527e20bd646dbfeb7d1082c03e5354609d2
+  data.tar.gz: ceed1b93aeded65a534581dc185d5413bbdf8e90869d1abbe56419d76fa4cba6406071a127a8370bdff9f17c0441efe2fc1460b2da3462b88a102c7f0a5b7b6a

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Koichiro Ohba
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,113 @@
+# Miniradio Server is Simple Ruby HLS Server for MP3s
+This is a basic HTTP Live Streaming (HLS) server written in Ruby using the Rack interface. It serves MP3 audio files by converting them on-the-fly into HLS format (M3U8 playlist and MP3 segment files) using `ffmpeg`. Converted files are cached for subsequent requests.
+This server is designed for simplicity and primarily targets Video on Demand (VOD) scenarios where you want to stream existing MP3 files via HLS without pre-converting them.
+
+## Prerequisites
+Before running the server, ensure you have the following installed:
+1.  **Ruby:** Version 3.1 or later (tested on 3.4).
+2.  **Dependency Gems:** Install using `bundle`.
+3.  **FFmpeg:** A recent version of `ffmpeg` must be installed and accessible in your system's PATH. You can download it from [ffmpeg.org](https://ffmpeg.org/) or install it via your system's package manager (e.g., `apt install ffmpeg`, `brew install ffmpeg`).
+## Setup
+1.  **Install Gems:**
+    ```bash
+    gem install miniradio_server
+    ```
+2.  **Create MP3 Directory:** Create a directory named `mp3_files` in the same location as the script.
+    ```bash
+    mkdir mp3_files
+    ```
+    *(Alternatively, change the `MP3_SRC_DIR` constant in the script).*
+3.  **Add MP3 Files:** Place the MP3 files you want to stream into the `mp3_files` directory.
+    *   **Important:** Use simple, URL-safe filenames for your MP3s (e.g., letters, numbers, underscores, hyphens). Spaces or special characters might cause issues. Example: `my_cool_song.mp3`, `podcast_episode_1.mp3`.
+4.  **Cache Directory:** The script will automatically create a `hls_cache` directory (or the directory specified by `HLS_CACHE_DIR`) when the first conversion occurs. Ensure the script has write permissions in its parent directory.
+
+## Running the Server
+Navigate to the directory containing the script in your terminal and run:
+
+```bash
+bin/miniradio_server
+Info: ffmpeg found.
+Starting HLS conversion and streaming server on port 9292...
+MP3 Source Directory: /path/to/your/project/mp3_files
+HLS Cache Directory: /path/to/your/project/hls_cache
+Default External Encoding: UTF-8
+Using Handler: Rackup::Handler::WEBrick
+Example Streaming URL: http://localhost:9292/stream/{mp3_filename_without_extension}/playlist.m3u8
+e.g., If mp3_files/ contains my_music.mp3 -> http://localhost:9292/stream/my_music/playlist.m3u8
+Press Ctrl+C to stop.
+```
+
+The server will run in the foreground. Press Ctrl+C to stop it.
+
+## Usage: Accessing Streams
+
+Once the server is running, you can access the HLS streams using an HLS-compatible player (like VLC, QuickTime Player on macOS/iOS, Safari, or web players using hls.js).
+
+The URL format is:
+
+http\://localhost:{SERVER\_PORT}/stream/{mp3\_filename\_without\_extension}/playlist.m3u8
+
+**Example:**
+
+If you have an MP3 file named mp3\_files/awesome\_track.mp3 and the server is running on the default port 9292, the streaming URL would be:
+
+http\://localhost:9292/stream/awesome\_track/playlist.m3u8
+
+**Note:** The first time you request a specific stream, the server will run ffmpeg to convert the MP3. This might take a few seconds depending on the file size. Subsequent requests for the same stream will be served instantly from the cache.
+
+## Configuration
+
+You can modify the following constants at the top of the script (miniradio\_server.rb):
+
+- MP3\_SRC\_DIR: Path to the directory containing your original MP3 files.
+- HLS\_CACHE\_DIR: Path to the directory where HLS segments and playlists will be cached.
+- SERVER\_PORT: The network port the server listens on.
+- FFMPEG\_COMMAND: The command used to execute ffmpeg (change if it's not in your PATH).
+- HLS\_SEGMENT\_DURATION: The target duration (in seconds) for each HLS segment.
+
+## How it Works
+
+1. A client requests an M3U8 playlist URL (e.g., /stream/my\_song/playlist.m3u8).
+2. The server checks if the corresponding HLS files (hls\_cache/my\_song/playlist.m3u8 and segments) exist in the cache directory.
+3. If the cache does not exist:
+   - It verifies the original mp3\_files/my\_song.mp3 exists.
+   - It acquires a lock specific to my\_song to prevent simultaneous conversions.
+   - It runs ffmpeg to convert my\_song.mp3 into hls\_cache/my\_song/playlist.m3u8 and hls\_cache/my\_song/segmentXXX.mp3.
+   - The lock is released.
+4. If the cache does exist (or after successful conversion), the server serves the requested playlist.m3u8 file.
+5. The client parses the M3U8 playlist and requests the individual MP3 segment files listed within it (e.g., /stream/my\_song/segment000.mp3, /stream/my\_song/segment001.mp3, etc.).
+6. The server serves these segment files directly from the cache directory.
+
+## Limitations
+
+- **VOD Only:** This server is designed for Video on Demand (pre-existing files) and does not support live streaming.
+- **Basic Caching:** Cache is persistent but simple. There's no automatic cache invalidation if the source MP3 changes. You would need to manually clear the corresponding subdirectory in hls\_cache.
+- **Security:** Basic checks against directory traversal are included, but it's not hardened for production use against malicious requests. No authentication/authorization is implemented.
+- **Performance:** Relies on ffmpeg execution per file (first request only). Uses Ruby's WEBrick via rackup, which is single-threaded by default and not ideal for high-concurrency production loads.
+- **Error Handling:** Basic error handling is implemented, but complex ffmpeg issues or edge cases might not be handled gracefully.
+- **Resource Usage:** Conversion can be CPU-intensive (though -c:a copy helps significantly) and disk I/O intensive during the first request for a file.
+
+
+## Development
+
+Install from git repository:
+
+```bash
+git clone https://github.com/koichiro/miniradio_server.git
+cd miniradio_server
+bundle
+bin/miniradio_server
+```
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/koichiro/miniradio_server.
+
+## License
+
+This project is licensed under the [MIT License](https://opensource.org/licenses/MIT) - see the LICENSE file for details (or assume MIT if no LICENSE file is present).
+

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+task default: :test

data/lib/miniradio_server/app.rb

@@ -0,0 +1,296 @@
+# -*- coding: utf-8 -*-
+require 'rack'
+require 'open3' # Used in convert_to_hls
+
+# Required to use the handler from Rack 3+
+# You might need to run: gem install rackup
+require 'rackup/handler/webrick'
+
+# Rack application class
+module MiniradioServer
+  class App
+    def initialize(mp3_dir, cache_dir, ffmpeg_cmd, segment_duration, logger)
+      @mp3_dir = Pathname.new(mp3_dir).realpath
+      @cache_dir = Pathname.new(cache_dir).realpath
+      @ffmpeg_cmd = ffmpeg_cmd
+      @segment_duration = segment_duration
+      @logger = logger
+      # For managing locks during conversion processing (using Mutex per file)
+      @conversion_locks = Hash.new { |h, k| h[k] = Mutex.new } # Mutex is built-in, no require needed
+    end
+
+    def call(env)
+      request_path = env['PATH_INFO']
+      @logger.info "Request received: #{request_path}"
+
+      # Path pattern: /stream/{mp3_basename}/{playlist or segment}
+      # mp3_basename is the filename without the extension
+      match = request_path.match(%r{^/stream/([^/]+)/(.+\.(m3u8|mp3))$})
+
+      unless match
+        @logger.warn "Invalid request path format: #{request_path}"
+        return not_found_response("Not Found (Invalid Path Format)")
+      end
+
+      mp3_basename = match[1] # e.g., "your_music" (without extension)
+      requested_filename = match[2] # e.g., "playlist.m3u8" or "segment001.mp3"
+      extension = match[3].downcase # "m3u8" or "mp3"
+
+      # --- Check if the original MP3 file exists ---
+      # Security: Check for directory traversal in basename
+      if mp3_basename.include?('..') || mp3_basename.include?('/')
+        @logger.warn "Invalid MP3 base name requested: #{mp3_basename}"
+        return forbidden_response("Invalid filename.")
+      end
+      original_mp3_path = @mp3_dir.join("#{mp3_basename}.mp3")
+
+      unless original_mp3_path.exist? && original_mp3_path.file?
+        @logger.warn "Original MP3 file not found: #{original_mp3_path}"
+        return not_found_response("Not Found (Original MP3)")
+      end
+
+      # --- Build cache paths ---
+      cache_subdir = @cache_dir.join(mp3_basename)
+      hls_playlist_path = cache_subdir.join("playlist.m3u8")
+      requested_cache_file_path = cache_subdir.join(requested_filename)
+
+      # Security: Check if the requested cache file path is within the cache subdirectory
+      # Use string comparison as realpath fails if the file doesn't exist yet
+      unless requested_cache_file_path.to_s.start_with?(cache_subdir.to_s + File::SEPARATOR) || requested_cache_file_path == hls_playlist_path
+        @logger.warn "Attempted access outside cache directory: #{requested_cache_file_path}"
+        return forbidden_response("Access denied.")
+      end
+
+      # --- Process based on request type ---
+      if extension == 'm3u8'
+        # M3U8 request: Check if conversion is needed, convert if necessary, and serve
+        ensure_hls_converted(original_mp3_path, cache_subdir, hls_playlist_path) do |status, message|
+          case status
+          when :ok, :already_exists
+            return serve_file(hls_playlist_path)
+          when :converting
+            # Another process/thread is converting
+            return service_unavailable_response("Conversion in progress. Please try again shortly.")
+          when :error
+            return internal_server_error_response(message || "HLS conversion failed.")
+          end
+        end
+      elsif extension == 'mp3'
+        # MP3 segment request: Serve from cache (404 if not found)
+        # Normally, the m3u8 is requested first, so the cache should exist
+        if requested_cache_file_path.exist? && requested_cache_file_path.file?
+          return serve_file(requested_cache_file_path)
+        else
+          # Segment request might come before m3u8, or an invalid request after conversion failure
+          @logger.warn "Segment file not found (cache not generated or invalid request?): #{requested_cache_file_path}"
+          # For simplicity, return 404. A more robust check might verify parent conversion status.
+          return not_found_response("Not Found (Segment)")
+        end
+      else
+        # Should not reach here
+        @logger.error "Unexpected file extension: #{extension}"
+        return internal_server_error_response
+      end
+
+    rescue SystemCallError => e # File access related errors (ENOENT, EACCES, etc.)
+      @logger.error "File access error: #{e.message}"
+      # Return 404 or 500 depending on the context
+      return not_found_response("Resource not found or access denied")
+    rescue => e
+      @logger.error "Unexpected error occurred: #{e.message}"
+      @logger.error e.backtrace.join("\n")
+      return internal_server_error_response
+    end
+
+    private
+
+    # Check if HLS conversion is needed and execute if necessary (with lock)
+    # Yields the status (:ok, :already_exists, :converting, :error) and an optional message to the block
+    def ensure_hls_converted(input_mp3_path, output_dir, playlist_path)
+      mp3_basename = input_mp3_path.basename('.mp3').to_s
+      lock = @conversion_locks[mp3_basename] # Get the Mutex specific to this file
+
+      # Check if the converted file already exists (check outside lock for speed)
+      if playlist_path.exist?
+        yield(:already_exists, nil)
+        return
+      end
+
+      # Use Mutex for exclusive control of conversion processing
+      if lock.try_lock # If the lock is acquired, execute the conversion process
+        begin
+          # After acquiring the lock, check file existence again (another thread might have just finished)
+          if playlist_path.exist?
+            yield(:already_exists, nil)
+            return
+          end
+
+          @logger.info "[#{mp3_basename}] Starting HLS conversion..."
+          success, error_msg = convert_to_hls(input_mp3_path, output_dir)
+
+          if success
+            @logger.info "[#{mp3_basename}] HLS conversion completed."
+            yield(:ok, nil)
+          else
+            @logger.error "[#{mp3_basename}] HLS conversion failed. Error: #{error_msg}"
+            yield(:error, error_msg)
+          end
+        ensure
+          lock.unlock # Always release the lock
+        end
+      else
+        # Failed to acquire lock = another thread is converting
+        @logger.info "[#{mp3_basename}] is currently being converted by another request."
+        yield(:converting, nil)
+      end
+    end
+
+
+    # Convert MP3 file to HLS format (execute ffmpeg)
+    # Returns: [Boolean (success/failure), String (error message or nil)]
+    def convert_to_hls(input_mp3_path, output_dir)
+      # Create the output directory
+      FileUtils.mkdir_p(output_dir) unless output_dir.exist?
+
+      playlist_path = output_dir.join("playlist.m3u8")
+      segment_path_template = output_dir.join("segment%03d.mp3") # %03d is replaced by ffmpeg with sequence number
+
+      # Build the ffmpeg command (using an array is safer for paths with spaces)
+      cmd = [
+        @ffmpeg_cmd,
+        '-y',                               # Overwrite existing files (just in case)
+        '-i', input_mp3_path.to_s,
+        '-c:a', 'copy',                     # Copy audio codec (no re-encoding)
+        '-f', 'hls',
+        '-hls_time', @segment_duration.to_s,
+        '-hls_list_size', '0',              # VOD (include all segments in the list)
+        '-hls_playlist_type', 'vod',        # Specify VOD playlist type
+        '-hls_segment_filename', segment_path_template.to_s,
+        playlist_path.to_s
+      ]
+
+      @logger.info "Executing command: #{cmd.join(' ')}"
+
+      # Execute command (capture standard output, standard error, and status)
+      stdout, stderr, status = Open3.capture3(*cmd)
+
+      unless status.success?
+        error_message = "ffmpeg exited with status #{status.exitstatus}. Stderr: #{stderr.strip}"
+        @logger.error "ffmpeg command execution failed. #{error_message}"
+        # If failed, attempt to delete potentially incomplete cache directory
+        begin
+          FileUtils.rm_rf(output_dir.to_s) if output_dir.exist?
+        rescue => e
+          @logger.error "Error occurred while deleting cache directory: #{output_dir}, Error: #{e.message}"
+        end
+        return [false, error_message]
+      end
+
+      # Log warnings from stderr even on success (if necessary), ignoring common deprecation warnings
+      unless stderr.empty? || stderr.strip.downcase.include?('deprecated')
+        @logger.warn "ffmpeg stderr (on success): #{stderr.strip}"
+      end
+
+      return [true, nil]
+
+    rescue Errno::ENOENT => e # Command not found, etc.
+      error_message = "Error occurred during ffmpeg command preparation: #{e.message}"
+      @logger.error error_message
+      return [false, error_message]
+    rescue => e # Catch other exceptions around ffmpeg execution
+      error_message = "Unexpected error occurred during ffmpeg execution: #{e.message}"
+      @logger.error error_message
+      # Attempt to clean up cache dir on unexpected error too
+      begin
+        FileUtils.rm_rf(output_dir.to_s) if output_dir.exist?
+      rescue => e_rm
+        @logger.error "Error occurred while deleting cache directory: #{output_dir}, Error: #{e_rm.message}"
+      end
+      return [false, error_message]
+    end
+
+    # Serve the file
+    def serve_file(file_path)
+      extension = file_path.extname.downcase
+      content_type = case extension
+      when '.m3u8'
+        'application/vnd.apple.mpegurl' # Or 'audio/mpegurl'
+      when '.mp3'
+        'audio/mpeg'
+      else
+        @logger.warn "Serving attempt: Unsupported file type: #{file_path}"
+        return forbidden_response("Unsupported file type.")
+      end
+
+      # Re-check file existence and type (just before serving)
+      unless file_path.exist? && file_path.file?
+        @logger.warn "File to serve not found (serve_file): #{file_path}"
+        return not_found_response("Not Found (Serving File)")
+      end
+
+      # Get file size (with error handling)
+      begin
+        file_size = file_path.size
+      rescue Errno::ENOENT
+        @logger.error "Failed to get file size (file disappeared?): #{file_path}"
+        return not_found_response("Not Found (File disappeared)")
+      rescue SystemCallError => e # Other file access errors
+        @logger.error "Failed to get file size: #{file_path}, Error: #{e.message}"
+        return internal_server_error_response("Failed to get file size")
+      end
+
+
+      headers = {
+        'Content-Type' => content_type,
+        'Content-Length' => file_size.to_s,
+        'Access-Control-Allow-Origin' => '*', # CORS header
+        # For HLS, it's often safer not to cache (especially for live streams)
+        # For VOD, caching might be okay, but we'll disable it here for simplicity
+        'Cache-Control' => 'no-cache, no-store, must-revalidate',
+        'Pragma' => 'no-cache',
+        'Expires' => '0'
+      }
+
+      @logger.info "Serving: #{file_path} (#{content_type}, #{file_size} bytes)"
+
+      # Return the File object as the response body (Rack handles streaming efficiently)
+      begin
+        # Open in binary mode
+        file_body = file_path.open('rb')
+        [200, headers, file_body]
+      rescue SystemCallError => e # Error during file opening
+        @logger.error "Failed to open file: #{file_path}, Error: #{e.message}"
+        # Rack should handle closing the file even if opened, so no explicit close needed here
+        internal_server_error_response("Failed to open file")
+      end
+    end
+
+    # --- HTTP Status Code Response Methods ---
+    def response(status, message, content_type = 'text/plain', extra_headers = {})
+      headers = {
+        'Content-Type' => content_type,
+        'Access-Control-Allow-Origin' => '*'
+      }.merge(extra_headers)
+      # Returning the body as an array is the Rack specification
+      [status, headers, [message + "\n"]]
+    end
+
+    def not_found_response(message = "Not Found")
+      response(404, message)
+    end
+
+    def forbidden_response(message = "Forbidden")
+      response(403, message)
+    end
+
+    def internal_server_error_response(message = "Internal Server Error")
+      response(500, message)
+    end
+
+    def service_unavailable_response(message = "Service Unavailable")
+      # Add Retry-After header suggesting a retry after 5 seconds
+      response(503, message, 'text/plain', { 'Retry-After' => '5' })
+    end
+  end
+end
+

data/lib/miniradio_server/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MiniradioServer
+  VERSION = "0.0.1"
+end

data/lib/miniradio_server.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'pathname'
+require 'fileutils'
+
+require_relative "miniradio_server/version"
+
+module MiniradioServer
+  class Error < StandardError; end
+
+  # --- Configuration ---
+  # Directory containing the original MP3 files
+  MP3_SRC_DIR = File.expand_path('./mp3_files')
+  # Directory to cache the HLS converted content
+  HLS_CACHE_DIR = File.expand_path('./hls_cache')
+  # Port the server will listen on
+  SERVER_PORT = 9292
+  # Path to the ffmpeg command (usually just 'ffmpeg' if it's in the system PATH)
+  FFMPEG_COMMAND = 'ffmpeg'
+  # HLS segment duration in seconds
+  HLS_SEGMENT_DURATION = 10
+  # ---
+
+  # --- Helper Methods ---
+
+  # Ensures that the necessary directories exist, creating them if they don't.
+  # @param dirs [Array<String>] An array of directory paths to check and create.
+  # @param logger [Logger] Logger instance for outputting information.
+  def self.ensure_directories_exist(dirs, logger)
+    dirs.each do |dir|
+      unless Dir.exist?(dir)
+        logger.info("Creating directory: #{dir}")
+        FileUtils.mkdir_p(dir)
+      end
+    end
+  end
+end
+
+require_relative "miniradio_server/app"
+
+# --- Server Startup ---
+
+# Only run server startup logic if the script is executed directly
+if __FILE__ == $PROGRAM_NAME || 'bin/miniradio_server' == $PROGRAM_NAME || 'miniradio_server' == $PROGRAM_NAME
+  logger = Logger.new(STDOUT)
+  # Ensure directories exist before starting the app
+  # Use constants defined within the module
+  MiniradioServer.ensure_directories_exist(
+    [MiniradioServer::MP3_SRC_DIR, MiniradioServer::HLS_CACHE_DIR],
+    logger
+  )
+
+  logger.level = Logger::INFO
+
+  # Check encoding settings, especially for non-ASCII filenames
+  Encoding.default_external = Encoding::UTF_8 if Encoding.default_external != Encoding::UTF_8
+  # Encoding.default_internal = Encoding::UTF_8 # Set internal encoding if needed
+
+  # Use constants defined within the module
+  app = MiniradioServer::App.new(
+    MiniradioServer::MP3_SRC_DIR,
+    MiniradioServer::HLS_CACHE_DIR,
+    MiniradioServer::FFMPEG_COMMAND,
+    MiniradioServer::HLS_SEGMENT_DURATION,
+    logger
+  )
+
+  puts "Starting HLS conversion and streaming server on port #{MiniradioServer::SERVER_PORT}..."
+  puts "MP3 Source Directory: #{MiniradioServer::MP3_SRC_DIR}"
+  puts "HLS Cache Directory: #{MiniradioServer::HLS_CACHE_DIR}"
+  puts "Default External Encoding: #{Encoding.default_external}" # For confirmation log
+  puts "Using Handler: Rackup::Handler::WEBrick" # For confirmation log
+  puts "Example Streaming URL: http://localhost:#{MiniradioServer::SERVER_PORT}/stream/{mp3_filename_without_extension}/playlist.m3u8"
+  puts "e.g., If mp3_files/ contains my_music.mp3 -> http://localhost:#{MiniradioServer::SERVER_PORT}/stream/my_music/playlist.m3u8"
+  puts "Press Ctrl+C to stop."
+
+  begin
+    # Use Rackup::Handler::WEBrick, recommended for Rack 3+
+    Rackup::Handler::WEBrick.run(
+      app,
+      Port: MiniradioServer::SERVER_PORT,
+      Logger: logger,       # Share logger with WEBrick
+      AccessLog: []       # Disable WEBrick's own access log (logging handled by Rack app)
+      # , :DoNotReverseLookup => true # Disable DNS reverse lookup for faster responses (optional)
+    )
+  rescue Interrupt # When stopped with Ctrl+C
+    puts "\nShutting down server."
+  rescue Errno::EADDRINUSE # Port already in use
+    puts "Error: Port #{MiniradioServer::SERVER_PORT} is already in use."
+    exit(1)
+  rescue LoadError => e
+    # Error handling if rackup/handler/webrick is not found
+    if e.message.include?('rackup/handler/webrick')
+      puts "Error: Rackup WEBrick handler not found."
+      puts "Please install the rackup gem by running: `gem install rackup`"
+    else
+      puts "Library load error: #{e.message}"
+    end
+    exit(1)
+  rescue => e
+    puts "Server startup error: #{e.message}"
+    puts e.backtrace.join("\n")
+    exit(1)
+  end
+end

data/sig/miniradio_server.rbs

@@ -0,0 +1,4 @@
+module MiniradioServer
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: miniradio_server
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Koichiro Ohba
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: irb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.16'
+- !ruby/object:Gem::Dependency
+  name: rackup
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: open3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |2
+      This is a basic HTTP Live Streaming (HLS) server written in Ruby using the Rack interface. It serves MP3 audio files by converting them on-the-fly into HLS format (M3U8 playlist and MP3 segment files) using `ffmpeg`. Converted files are cached for subsequent requests.
+      This server is designed for simplicity and primarily targets Video on Demand (VOD) scenarios where you want to stream existing MP3 files via HLS without pre-converting them.
+email:
+- koichiro.ohba@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- hls_cache/.gitkeep
+- lib/miniradio_server.rb
+- lib/miniradio_server/app.rb
+- lib/miniradio_server/version.rb
+- mp3_files/.gitkeep
+- sig/miniradio_server.rbs
+homepage: https://github.com/koichiro/miniradio_server
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/koichiro/miniradio_server
+  source_code_uri: https://github.com/koichiro/miniradio_server.git
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Miniradio Server is Simple Ruby HLS Server for MP3s.
+test_files: []