minio_runner 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fee26785f28262a4b0f39f5020886edcddd996ca6040e5b1e952a9583199aa36
+  data.tar.gz: 19ba0e2e0a070b3caf5fbfc1ba04e4a5cca9a285e80b224626e112cbd45c0202
+SHA512:
+  metadata.gz: 57fc047cd89912f6ad31b2fc5c349d74182c44fdc9bf6ef2e5cc5beb613eff56d99ff04914761047c0deb944bb433e581e8f0017000fdc8309a0a3af1628f1bd
+  data.tar.gz: 5a16f8c6d73deec031690b3bdb21d602d6e162ab22a8b56f4ab6abd874bfe0aa039bb4c31a1de79245c0116cabc7118d58ded7d9b499f1f8b018beabdd633aeb

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in minio_runner.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "minitest", "~> 5.0"

data/Gemfile.lock

@@ -0,0 +1,93 @@
+PATH
+  remote: .
+  specs:
+    minio_runner (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ansi (1.5.0)
+    ast (2.4.2)
+    builder (3.2.4)
+    byebug (11.1.3)
+    coderay (1.1.3)
+    json (2.6.3)
+    language_server-protocol (3.17.0.3)
+    method_source (1.0.0)
+    minitest (5.19.0)
+    minitest-color (0.0.2)
+      minitest (~> 5)
+    minitest-line (0.6.5)
+      minitest (~> 5.0)
+    minitest-reporters (1.6.1)
+      ansi
+      builder
+      minitest (>= 5.0)
+      ruby-progressbar
+    parallel (1.23.0)
+    parser (3.2.2.3)
+      ast (~> 2.4.1)
+      racc
+    prettier_print (1.2.1)
+    pry (0.14.2)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    pry-byebug (3.10.1)
+      byebug (~> 11.0)
+      pry (>= 0.13, < 0.15)
+    racc (1.7.1)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.8.1)
+    rexml (3.2.6)
+    rubocop (1.55.1)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.2.2.3)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.28.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.29.0)
+      parser (>= 3.2.1.0)
+    rubocop-capybara (2.18.0)
+      rubocop (~> 1.41)
+    rubocop-discourse (3.3.0)
+      rubocop (>= 1.1.0)
+      rubocop-rspec (>= 2.0.0)
+    rubocop-factory_bot (2.23.1)
+      rubocop (~> 1.33)
+    rubocop-rspec (2.23.0)
+      rubocop (~> 1.33)
+      rubocop-capybara (~> 2.17)
+      rubocop-factory_bot (~> 2.22)
+    ruby-progressbar (1.13.0)
+    spy (1.0.5)
+    syntax_tree (6.1.1)
+      prettier_print (>= 1.2.0)
+    syntax_tree-disable_ternary (1.0.0)
+    unicode-display_width (2.4.2)
+
+PLATFORMS
+  arm64-darwin-21
+  x86_64-linux
+
+DEPENDENCIES
+  minio_runner!
+  minitest (~> 5.0)
+  minitest-color
+  minitest-line
+  minitest-reporters
+  pry
+  pry-byebug
+  rake (~> 13.0)
+  rubocop-discourse
+  spy
+  syntax_tree
+  syntax_tree-disable_ternary
+
+BUNDLED WITH
+   2.4.13

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Martin Brennan
+
+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,163 @@
+# MinioRunner
+
+Manages the installed [minio](https://min.io/) binary and handles setup and
+teardown of the minio server.
+
+## Description
+
+This is a simple way of managing the locally installed minio server using an
+installed binary. This can be used to start/stop the server when running
+automated tests or developing locally against an S3 alternative. It also
+installs the [`mc` (minio client)](https://min.io/docs/minio/linux/reference/minio-mc.html) CLI
+tool to make interacting with the server easier.
+
+This an extremely focused gem and will not focus on all possible different
+configurations and binaries of minio. Only Linux and macOS platforms are
+supported at this time.
+
+This gem was inspired by the [webdrivers](https://github.com/titusfortner/webdrivers)
+project.
+
+## Usage
+
+In your Gemfile:
+
+```ruby
+gem 'minio_runner', require: false
+```
+
+In your project:
+
+```ruby
+require 'minio_runner'
+```
+
+The minio runner will not automatically locate, download, and start minio. You
+will need to use the following calls; for example in your before/after suite
+setup and teardown for rspec.
+
+```ruby
+# Locate and download the minio binary if it does not exist, and start the server with provided configuration.
+# The binary will be updated if the new version (which is checked every time `MinioRunner.cache_time` expires)
+# is greater than the installed version.
+MinioRunner.start
+
+# Stop the currently running server.
+MinioRunner.stop
+```
+
+### Download Location
+
+The default download location is `~/.minio_runner` directory, and this is configurable:
+
+ ```ruby
+MinioRunner.config.install_dir = '/minio_runner/install/dir'
+```
+
+Alternatively, you can define the path via the `MINIO_RUNNER_INSTALL_DIR` environment variable.
+The environment variable will take precedence.
+
+### Caching minio version
+
+You can set Minio Runner to only look for updates if the previous check
+was longer ago than a specified number of seconds.
+
+```ruby
+MinioRunner.config.cache_time = 86_400 # Default: 86,400 Seconds (24 hours)
+```
+
+Alternatively, you can define the time via the `MINIO_RUNNER_CACHE_TIME` environment variable.
+The environment variable will take precedence.
+
+### Rake tasks
+
+You can run `bundle exec rake -T -a` to see all the rake tasks. The ones specifically related to
+minio runner will be namespaced into minio_runner. 
+
+### Logging
+
+The logging level can be configured for debugging purpose via the `MINIO_RUNNER_LOG_LEVEL` environment variable.
+
+The available values are found in https://ruby-doc.org/stdlib-2.4.0/libdoc/logger/rdoc/Logger/Severity.html.
+
+The minio server will log to the `install_dir` in a `minio.log` file.
+
+## Minio configuration
+
+Only a small subset of minio configuration (defined at https://min.io/docs/minio/linux/reference/minio-server/minio-server.html#environment-variables)
+is supported. The subset of configuration options can be found from running the `list_configurable_env`
+rake task.
+
+All minio configuration can also be specified via `MinioRunner.config`, and anything
+set in this way will override environment variables. Environment variables should
+be in the format `MINIO_RUNNER_MINIO_X`:
+
+```ruby
+MinioRunner.config do |config|
+  config.minio_port = 9000 # MINIO_RUNNER_MINIO_PORT
+  config.minio_console_address = 9001 # MINIO_RUNNER_MINO_CONSOLE_ADDRESS
+  config.minio_domain = 'minio.local' # MINIO_RUNNER_MINIO_DOMAIN
+end
+```
+
+The configuration in ruby will use the exact same names as the environment
+variables for minio.
+
+### Aliases
+
+By default a `local` alias is automatically created via the `mc` tool, which will point
+to `localhost` at the configured `MINIO_RUNNER_MINIO_PORT`. No other aliases are supported
+at this time.
+
+### Buckets
+
+You can specify the buckets that will be created (if they do not exist) when the minio server
+starts using the `MinioRunner.config` call above or using the `MINIO_RUNNER_BUCKETS` environment
+variable with a comma-separated list. Only S3-compatible buckets will be made.
+
+```ruby
+MinioRunner.config.buckets = ["testbucket", "media"]
+
+# MINIO_RUNNER_BUCKETS="testbucket,media"
+```
+
+Buckets will be made public to anonymous users if they are specified in the `public_buckets` configuration,
+which can also be set with the `MINIO_RUNNER_PUBLIC_BUCKETS` environment variable.
+
+### Hosts file
+
+**An important step** that you must manually do yourself is to modify your `/etc/hosts` file to add an
+entry for your minio server defined by `MINIO_RUNNER_MINIO_DOMAIN` and also for any bucket defined
+via `MINIO_RUNNER_BUCKETS`, since they will be used as virtual-host style buckets.
+
+For example:
+
+```
+127.0.0.1 minio.local
+127.0.0.1 testbucket.minio.local
+```
+
+For macOS, there are some issues which cause large delays for .local domain names. See
+https://superuser.com/a/1297335/245469 and https://stackoverflow.com/a/17982964/875941. To
+resolve this, you need to add IPV6 lookup addresses to the hosts file, and it helps to put
+all the entries on one line.
+
+```
+::1 minio.local testbucket.minio.local
+fe80::1%lo0 minio.local testbucket.minio.local
+127.0.0.1 minio.local testbucket.minio.local
+```
+
+## Development
+
+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/discourse/minio_runner.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+require "bundler/setup"
+require "minio_runner"
+require "pry"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task default: :test
+
+namespace :minio_runner do
+  desc "Completely removes the minio runner install directory which includes binaries and version files"
+  task :remove do
+    MinioRunner.remove_install_dir
+  end
+
+  desc "Installs the minio and mc binaries"
+  task :install do
+    MinioRunner.install_binaries
+  end
+
+  desc "Forces an update of the binaries. Equivalent to running the remove then install tasks."
+  task :update do
+    MinioRunner.remove_install_dir
+    MinioRunner.install_binaries
+  end
+
+  desc "Installs binaries, starts the minio server, and makes sure it is set up to receive requests. Stops server on exit."
+  task :start do
+    MinioRunner.start
+    MinioRunner.logger.info("Minio server is now started. Press any key to stop.")
+    STDIN.gets.strip
+  end
+
+  desc "Lists all environment varibales that can be configured for MinioRunner"
+  task :list_configurable_env do
+    puts "These are the configurable environment variables for MinioRunner:"
+    puts "-" * 20
+
+    MinioRunner::Config::CONFIGURABLE_ENV_VARS
+      .sort_by { |key| key }
+      .each do |key, value|
+        printf "%-40s %s\n", "#{MinioRunner::System::ENV_VAR_PREFIX}#{key.upcase}", value
+      end
+  end
+end

data/lib/minio_runner/base_binary.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "system"
+
+module MinioRunner
+  class BaseBinary
+    class << self
+      def sha_file_name
+        "#{name}.sha256sum"
+      end
+
+      def version_file_name
+        "#{name}.version"
+      end
+
+      def version_file_path
+        File.join(MinioRunner.config.install_dir, version_file_name)
+      end
+
+      def checksum_file_path
+        File.join(MinioRunner.config.install_dir, sha_file_name)
+      end
+
+      def binary_file_path
+        File.join(MinioRunner.config.install_dir, name)
+      end
+
+      def platform_binary_url
+        "#{platform_base_url}#{name}"
+      end
+
+      def platform_sha256sum_url
+        "#{platform_binary_url}.sha256sum"
+      end
+
+      def name
+        raise NotImplementedError
+      end
+
+      def base_url
+        raise NotImplementedError
+      end
+
+      def platform_base_url
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/minio_runner/binary_manager.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "network"
+
+module MinioRunner
+  class BinaryManager
+    class << self
+      def install(binary)
+        new(binary).install
+      end
+    end
+
+    attr_reader :binary
+
+    def initialize(binary)
+      @binary = binary
+    end
+
+    def install
+      if installed?
+        if version_cache_expired? && new_version_available?
+          MinioRunner.logger.debug("New version of #{binary.name} available. Downloading...")
+          download_binary
+        else
+          MinioRunner.logger.debug("Version for #{binary.name} is up to date.")
+        end
+      else
+        MinioRunner.logger.debug("#{binary.name} not installed. Downloading...")
+        download_binary
+      end
+      MinioRunner.logger.debug("#{binary.name} installed successfully!")
+    end
+
+    def new_version_available?
+      old_version = File.read(binary.version_file_path)
+      new_version = nil
+
+      Network.download(binary.platform_sha256sum_url) do |sha_file|
+        new_version = File.read(sha_file.path)
+        FileUtils.cp(sha_file, File.join(MinioRunner.config.install_dir, binary.sha_file_name))
+        FileUtils.cp(sha_file, File.join(MinioRunner.config.install_dir, binary.version_file_name))
+      end
+
+      old_version != new_version
+    end
+
+    def download_binary
+      Network.download(binary.platform_binary_url) do |binary_file|
+        FileUtils.cp(binary_file, File.join(MinioRunner.config.install_dir, binary.name))
+      end
+
+      Network.download(binary.platform_sha256sum_url) do |sha_file|
+        FileUtils.cp(sha_file, File.join(MinioRunner.config.install_dir, binary.sha_file_name))
+        FileUtils.cp(sha_file, File.join(MinioRunner.config.install_dir, binary.version_file_name))
+      end
+
+      FileUtils.chmod("ugo+rx", binary.binary_file_path)
+    end
+
+    def installed?
+      File.exist?(binary.binary_file_path) && File.exist?(binary.version_file_path)
+    end
+
+    def version_cache_expired?
+      Time.now - File.mtime(binary.version_file_path) > MinioRunner.config.cache_time
+    end
+  end
+end

data/lib/minio_runner/child_process.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+# Copied with modification from https://github.com/SeleniumHQ/selenium/
+
+# Licensed to the Software Freedom Conservancy (SFC) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The SFC licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+module MinioRunner
+  #
+  # @api private
+  #
+
+  class ChildProcess
+    TimeoutError = Class.new(StandardError)
+
+    SIGTERM = "TERM"
+    SIGKILL = "KILL"
+
+    POLL_INTERVAL = 0.1
+
+    attr_accessor :detach
+    attr_writer :io
+    attr_reader :pid
+
+    def self.build(command, env: {}, log_file: File::NULL)
+      new(command, env: env, log_file: log_file)
+    end
+
+    def initialize(command, env: {}, log_file: File::NULL)
+      @command = command
+      @detach = false
+      @pid = nil
+      @status = nil
+      @env = env
+      @log_file = log_file
+    end
+
+    def io
+      @io ||= File::NULL
+    end
+
+    def start
+      options = { %i[out err] => @log_file }
+
+      # TODO (martin) Maybe don't log ENV here?
+      MinioRunner.logger.debug("Starting process: #{@command} with #{options} and ENV #{@env}")
+      @pid = Process.spawn(@env, @command.join(" "), options)
+      MinioRunner.logger.debug("  -> pid: #{@pid}")
+
+      Process.detach(@pid) if detach
+    end
+
+    def stop(timeout = 3)
+      return unless @pid
+      return if exited?
+
+      MinioRunner.logger.debug("Sending TERM to process: #{@pid}")
+      terminate(@pid)
+      poll_for_exit(timeout)
+
+      MinioRunner.logger.debug("  -> stopped #{@pid}")
+    rescue TimeoutError, Errno::EINVAL
+      MinioRunner.logger.debug("    -> sending KILL to process: #{@pid}")
+      kill(@pid)
+      wait
+      MinioRunner.logger.debug("      -> killed #{@pid}")
+    end
+
+    def alive?
+      @pid && !exited?
+    end
+
+    def exited?
+      return unless @pid
+
+      MinioRunner.logger.debug("Checking if #{@pid} is exited:")
+      _, @status = Process.waitpid2(@pid, Process::WNOHANG | Process::WUNTRACED) if @status.nil?
+      return if @status.nil?
+
+      exit_code = @status.exitstatus || @status.termsig
+      MinioRunner.logger.debug("  -> exit code is #{exit_code.inspect}")
+
+      !!exit_code
+    end
+
+    def poll_for_exit(timeout)
+      MinioRunner.logger.debug("Polling #{timeout} seconds for exit of #{@pid}")
+
+      end_time = Time.now + timeout
+      sleep POLL_INTERVAL until exited? || Time.now > end_time
+
+      raise TimeoutError, "  ->  #{@pid} still alive after #{timeout} seconds" unless exited?
+    end
+
+    def wait
+      return if exited?
+
+      _, @status = Process.waitpid2(@pid)
+    end
+
+    private
+
+    def terminate(pid)
+      Process.kill(SIGTERM, pid)
+    end
+
+    def kill(pid)
+      Process.kill(SIGKILL, pid)
+    rescue Errno::ECHILD, Errno::ESRCH
+      # already dead
+    end
+  end # ChildProcess
+end # MinioRunner

data/lib/minio_runner/config.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module MinioRunner
+  class Config
+    attr_accessor :install_dir, :cache_time, :buckets, :public_buckets, :log_level
+    attr_accessor :minio_data_directory,
+                  :minio_root_user,
+                  :minio_root_password,
+                  :minio_domain,
+                  :minio_port,
+                  :minio_console_port
+
+    DEFAULT_INSTALL_DIR = "~/.minio_runner"
+    DEFAULT_CACHE_TIME = 86_400 # 24 hours in seconds
+
+    DEFAULT_MINIO_SERVER_DATA_DIR = "~/.minio_runner/data"
+    DEFAULT_MINIO_PORT = 9000
+    DEFAULT_MINIO_CONSOLE_PORT = 9001
+    DEFAULT_MINIO_ROOT_USER = "minioadmin"
+    DEFAULT_MINIO_ROOT_PASSWORD = "minioadmin"
+
+    CONFIGURABLE_ENV_VARS = {
+      install_dir: "Path to install minio_runner (default #{DEFAULT_INSTALL_DIR})",
+      log_level:
+        "Log level for minio_runner (DEBUG, INFO, WARN, ERROR, FATAL, UNKNOWN, default INFO)",
+      cache_time:
+        "Time in seconds to cache minio_runner downloads for both the minio server and mc binaries (default #{DEFAULT_CACHE_TIME} seconds)",
+      buckets: "List of buckets to create on startup, comma separated.",
+      public_buckets: "List of buckets to make public for anonymous users, comma separated.",
+      minio_domain: "Domain to use for minio server (default localhost)",
+      minio_data_directory:
+        "Path to minio server data directory (default #{DEFAULT_MINIO_SERVER_DATA_DIR})",
+      minio_root_user: "User for minio server root user (default #{DEFAULT_MINIO_ROOT_USER})",
+      minio_root_password:
+        "Password for minio server root user (default #{DEFAULT_MINIO_ROOT_PASSWORD})",
+      minio_console_port: "Port for minio server console (default #{DEFAULT_MINIO_CONSOLE_PORT})",
+      minio_port: "Port for minio server (default #{DEFAULT_MINIO_PORT})",
+    }
+
+    def initialize
+      self.install_dir = System.env(:install_dir) || DEFAULT_INSTALL_DIR
+      self.cache_time = System.env(:cache_time) || DEFAULT_CACHE_TIME
+      self.buckets = System.env(:buckets)&.split(",") || []
+      self.public_buckets = System.env(:public_buckets)&.split(",") || []
+
+      # minio server configuration
+      self.minio_data_directory = System.env(:minio_data_directory) || DEFAULT_MINIO_SERVER_DATA_DIR
+      self.minio_root_user = System.env(:minio_root_user) || DEFAULT_MINIO_ROOT_USER
+      self.minio_root_password = System.env(:minio_root_password) || DEFAULT_MINIO_ROOT_PASSWORD
+      self.minio_domain = System.env(:minio_domain) || "localhost"
+      self.minio_port = System.env(:minio_port) || DEFAULT_MINIO_PORT
+      self.minio_console_port = System.env(:minio_console_port) || DEFAULT_MINIO_CONSOLE_PORT
+    end
+
+    def install_dir=(dir)
+      @install_dir = File.expand_path(dir)
+    end
+
+    def minio_data_directory=(dir)
+      @minio_data_directory = File.expand_path(dir)
+    end
+
+    def minio_server_url
+      "http://#{minio_domain}:#{minio_port}"
+    end
+
+    def minio_urls
+      urls = [minio_server_url]
+      buckets.each { |bucket| urls << "http://#{bucket}.#{minio_domain}:#{minio_port}" }
+      urls
+    end
+  end
+end

data/lib/minio_runner/mc_binary.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "base_binary"
+
+module MinioRunner
+  class McBinary < BaseBinary
+    class << self
+      def name
+        "mc"
+      end
+
+      def base_url
+        "https://dl.min.io/client/mc/release"
+      end
+
+      def platform_base_url
+        if System.linux?
+          "#{base_url}/linux-amd64/"
+        elsif System.mac?
+          System.mac_m? ? "#{base_url}/darwin-arm64/" : "#{base_url}/darwin-amd64/"
+        end
+      end
+    end
+  end
+end

data/lib/minio_runner/mc_manager.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module MinioRunner
+  class McManager
+    class << self
+      def command
+        ["#{MinioRunner::McBinary.binary_file_path}"]
+      end
+
+      def bucket_exists?(alias_name, name)
+        system(*command.concat(["ls", "#{alias_name}/#{name}"]))
+      end
+
+      def create_bucket(alias_name, name)
+        MinioRunner.logger.debug("Creating bucket #{alias_name}/#{name}...")
+        if !bucket_exists?(alias_name, name)
+          system(*command.concat(["mb", "#{alias_name}/#{name}"]))
+          MinioRunner.logger.debug("Created  #{alias_name}/#{name}.")
+        else
+          MinioRunner.logger.debug("Bucket #{alias_name}/#{name} already exists, doing nothing.")
+        end
+      end
+
+      def set_alias(name, url)
+        MinioRunner.logger.debug("Setting alias #{name} to #{url}...")
+        system(
+          *command.concat(
+            [
+              "alias",
+              "set",
+              name,
+              url,
+              MinioRunner.config.minio_root_user,
+              MinioRunner.config.minio_root_password,
+            ],
+          ),
+        )
+        MinioRunner.logger.debug("Set alias #{name} to #{url}.")
+      end
+
+      def set_anon(alias_name, bucket, policy)
+        MinioRunner.logger.debug(
+          "Setting anonymous access for #{alias_name}/#{bucket} to policy #{policy}...",
+        )
+        system(*command.concat(["anonymous", "set", policy, "#{alias_name}/#{bucket}"]))
+        MinioRunner.logger.debug("Anonymous access set for #{alias_name}/#{bucket}.")
+      end
+    end
+  end
+end

data/lib/minio_runner/minio_binary.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "base_binary"
+
+module MinioRunner
+  class MinioBinary < BaseBinary
+    class << self
+      def name
+        "minio"
+      end
+
+      def base_url
+        "https://dl.min.io/server/minio/release"
+      end
+
+      def platform_binary_url
+        "#{platform_base_url}#{name}"
+      end
+
+      def platform_sha256sum_url
+        "#{platform_binary_url}.sha256sum"
+      end
+
+      def platform_base_url
+        if System.linux?
+          "#{base_url}/linux-amd64/"
+        elsif System.mac?
+          System.mac_m? ? "#{base_url}/darwin-arm64/" : "#{base_url}/darwin-amd64/"
+        end
+      end
+    end
+  end
+end

data/lib/minio_runner/minio_server_manager.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative "child_process"
+
+module MinioRunner
+  class MinioServerManager
+    SERVER_STOP_TIMEOUT_SECONDS = 5
+
+    attr_reader :pid, :process
+
+    class << self
+      def start
+        @server = new
+        @server.start
+      end
+
+      def stop
+        return if @server.nil?
+        @server.stop
+      end
+    end
+
+    def start
+      if process_running?
+        MinioRunner.logger.debug("Already started minio server.")
+        return
+      end
+
+      MinioRunner.logger.debug("Starting minio server...")
+
+      MinioRunner::System.exit_hook { stop }
+
+      @process =
+        MinioRunner::ChildProcess.build(
+          server_command,
+          env: {
+            "MINIO_ROOT_USER" => MinioRunner.config.minio_root_user,
+            "MINIO_ROOT_PASSWORD" => MinioRunner.config.minio_root_password,
+            "MINIO_DOMAIN" => MinioRunner.config.minio_domain,
+          },
+          log_file: log_file_path,
+        )
+
+      @process.start
+
+      # Make sure the minio server is ready to accept requests.
+      health_check(retries: 3)
+
+      MinioRunner.logger.debug("minio server running at pid #{@process.pid}!")
+    end
+
+    def stop
+      return if process_exited?
+
+      MinioRunner.logger.debug("Stopping minio server running at pid #{@pid}...")
+      @process.stop(SERVER_STOP_TIMEOUT_SECONDS)
+      @process = nil
+      MinioRunner.logger.debug("minio server stopped")
+    end
+
+    def process_running?
+      defined?(@process) && @process&.alive?
+    end
+
+    def process_exited?
+      @process.nil? || @process.exited?
+    end
+
+    private
+
+    def server_command
+      command = []
+
+      # server start command for minio
+      command << "#{MinioRunner::MinioBinary.binary_file_path} server #{MinioRunner.config.minio_data_directory}"
+
+      # flags for minio
+      command << "--console-address :#{MinioRunner.config.minio_console_port}"
+      command << "--address #{MinioRunner.config.minio_domain}:#{MinioRunner.config.minio_port}"
+
+      command
+    end
+
+    def log_file_path
+      "#{MinioRunner.config.install_dir}/minio.log"
+    end
+
+    def health_check(retries:)
+      begin
+        Network.get("#{MinioRunner.config.minio_server_url}/minio/health/live")
+      rescue StandardError
+        if retries.positive?
+          sleep 1
+          health_check(retries: retries - 1)
+        else
+          raise "Minio server failed to start."
+        end
+      end
+    end
+  end
+end

data/lib/minio_runner/network.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "tempfile"
+
+module MinioRunner
+  class Network
+    class << self
+      def get(url)
+        MinioRunner.logger.debug("Making network call to #{url}")
+
+        begin
+          response = Net::HTTP.get_response(URI(url))
+        rescue SocketError
+          raise "Can not reach #{url}"
+        end
+
+        MinioRunner.logger.debug("Get response: #{response.inspect}")
+
+        case response
+        when Net::HTTPSuccess
+          response.body
+        else
+          raise "#{response.class::EXCEPTION_TYPE}: #{response.code} \"#{response.message}\" with #{url}"
+        end
+      end
+
+      def download(url, &block)
+        file_name = File.basename(url)
+        tempfile =
+          Tempfile.open(["", file_name], binmode: true) do |file|
+            file.print Network.get(url)
+            file
+          end
+
+        raise "Could not download #{url}" unless File.exist?(tempfile.to_path)
+
+        MinioRunner.logger.debug("Successfully downloaded #{tempfile.to_path}")
+
+        yield tempfile if block_given?
+      ensure
+        tempfile&.close!
+      end
+    end
+  end
+end

data/lib/minio_runner/system.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module MinioRunner
+  class System
+    class InvalidEnvVar < StandardError
+    end
+    class InvalidPlatform < StandardError
+    end
+
+    ENV_VAR_PREFIX = "MINIO_RUNNER_"
+
+    class << self
+      def env(name)
+        name = name.to_sym
+
+        if !defined_env?(name)
+          raise MinioRunner::System::InvalidEnvVar.new(
+                  "Environment variable #{ENV_VAR_PREFIX}#{name.upcase} is not valid for minio_runner.",
+                )
+        end
+
+        ENV["#{ENV_VAR_PREFIX}#{name.upcase}"]
+      end
+
+      def defined_env?(name)
+        MinioRunner::Config::CONFIGURABLE_ENV_VARS.keys.include?(name)
+      end
+
+      def make_install_dir
+        if !Dir.exist?(MinioRunner.config.install_dir)
+          MinioRunner.logger.debug("Making install directory #{MinioRunner.config.install_dir}.")
+          FileUtils.mkdir_p(MinioRunner.config.install_dir)
+        end
+      end
+
+      def valid_platform?
+        mac? || linux?
+      end
+
+      def validate_platform
+        if !valid_platform?
+          raise MinioRunner::System::InvalidPlatform.new(
+                  "MinioRunner only supports Mac, macOS and Linux.",
+                )
+        end
+      end
+
+      def mac?
+        Gem::Platform.local.os[/darwin|mac os/]
+      end
+
+      def mac_m?
+        mac? && Gem::Platform.local.cpu === "arm64"
+      end
+
+      def linux?
+        Gem::Platform.local.os[/linux/]
+      end
+
+      def exit_hook
+        pid = Process.pid
+        at_exit { yield if Process.pid == pid }
+      end
+    end
+  end
+end

data/lib/minio_runner/version.rb

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

data/lib/minio_runner.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "logger"
+require_relative "minio_runner/version"
+require_relative "minio_runner/system"
+require_relative "minio_runner/config"
+require_relative "minio_runner/minio_binary"
+require_relative "minio_runner/mc_binary"
+require_relative "minio_runner/binary_manager"
+require_relative "minio_runner/minio_server_manager"
+require_relative "minio_runner/mc_manager"
+
+module MinioRunner
+  class << self
+    def config(&block)
+      @config ||= MinioRunner::Config.new
+      if block_given?
+        yield @config
+      else
+        @config
+      end
+    end
+
+    def logger
+      @logger ||=
+        Logger
+          .new(STDOUT)
+          .tap do |logger|
+            logger.level =
+              (
+                if System.env(:log_level)
+                  Kernel.const_get("Logger::#{System.env(:log_level)}")
+                else
+                  Logger::INFO
+                end
+              )
+
+            original_formatter = logger.formatter || Logger::Formatter.new
+            logger.formatter =
+              proc do |severity, time, progname, msg|
+                original_formatter.call(
+                  severity,
+                  time,
+                  progname,
+                  "[MinioRunner]: #{msg.strip.dump}",
+                )
+              end
+          end
+    end
+
+    def start
+      logger.debug("Starting minio_runner...")
+
+      install_binaries
+      start_server
+      setup_alias
+      setup_buckets
+
+      logger.debug("Started minio_runner.")
+    end
+
+    def install_binaries
+      System.validate_platform
+      System.make_install_dir
+      MinioRunner::BinaryManager.install(MinioRunner::McBinary)
+      MinioRunner::BinaryManager.install(MinioRunner::MinioBinary)
+    end
+
+    def start_server
+      MinioRunner::MinioServerManager.start
+    end
+
+    def setup_alias
+      MinioRunner::McManager.set_alias("local", "http://localhost:#{MinioRunner.config.minio_port}")
+    end
+
+    def setup_buckets
+      MinioRunner.config.buckets.each do |bucket|
+        MinioRunner::McManager.create_bucket("local", bucket)
+      end
+      MinioRunner.config.public_buckets.each do |bucket|
+        MinioRunner::McManager.set_anon("local", bucket, "public")
+      end
+    end
+
+    def stop
+      logger.debug("Stopping minio_runner...")
+      MinioRunner::MinioServerManager.stop
+      logger.debug("Stopped minio_runner.")
+    end
+
+    def reset_config!
+      @config = nil
+    end
+
+    def remove_install_dir
+      logger.info("Removing MinioRunner install directory at #{MinioRunner.config.install_dir}...")
+      FileUtils.rm_rf(MinioRunner.config.install_dir) if Dir.exist?(MinioRunner.config.install_dir)
+      logger.info("Done removing MinioRunner install directory.")
+    end
+  end
+end

metadata

@@ -0,0 +1,186 @@
+--- !ruby/object:Gem::Specification
+name: minio_runner
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Martin Brennan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-08-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: syntax_tree
+  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: syntax_tree-disable_ternary
+  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: rubocop-discourse
+  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: minitest-color
+  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: minitest-reporters
+  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: minitest-line
+  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: spy
+  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: pry
+  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: pry-byebug
+  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'
+description: Manages local minio binary installs and handles stopping and starting
+  minio server
+email: martin@discourse.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/minio_runner.rb
+- lib/minio_runner/base_binary.rb
+- lib/minio_runner/binary_manager.rb
+- lib/minio_runner/child_process.rb
+- lib/minio_runner/config.rb
+- lib/minio_runner/mc_binary.rb
+- lib/minio_runner/mc_manager.rb
+- lib/minio_runner/minio_binary.rb
+- lib/minio_runner/minio_server_manager.rb
+- lib/minio_runner/network.rb
+- lib/minio_runner/system.rb
+- lib/minio_runner/version.rb
+homepage: https://rubygemspec.org/gems/minio_runner
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: Manages local minio binary installs
+test_files: []