cgminer_api_client 0.3.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 129410d116f95439ef734a1ae6265c047eb7f95007755e5788fc416e78741388
-  data.tar.gz: 386bd4f91ce093e290777a1b00be6efaa173f03f951b8bcc00d4b8683ce0c576
+  metadata.gz: d045472d7098443d965f6bb948ad45aef2698f84e188f6b41769905dcccf6ce4
+  data.tar.gz: a3ac02b6c4b94d9a797a3fd501cb43f7f35ee421b4234af49b92a3fcc48c7832
 SHA512:
-  metadata.gz: d7ebd6316421e95755768cf0f77dd672e3860c2fd508fd2314cc898f46b9c76d39efc78d3b1f4ac422c873871e1896b5fb8859e681c8ff3712f5f60f12c85351
-  data.tar.gz: 99a4578907f13668e8f0bf5cf466298f40774e318d3f470ad38df7f0cfa2455b51c028866084a264201156b6e30505daf7849e1d6a12aec4122ec5092d788fed
+  metadata.gz: e75c9159055d5a5a0507b11e93f0f0a25512f83e2bebb0de9a9495aa7829b018b4c9a2da555d795f8a6d6372ea99b75ebc363bf84f5c9a3fd7d085a63e34b3d2
+  data.tar.gz: d112135f844f48772daac286dbf6f3d81224820a6cf91cc7039b9e56ef3164dc38e2357c0f48c9a4d484a40dd2cb9346f0ba8522a5094cbb027cf6356863d4b9

data/CHANGELOG.md

@@ -5,6 +5,114 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [0.4.1] - 2026-09-22
+
+### Fixed
+- `Miner` keeps parsing responses that repeat a key under json 3.0,
+  which rejects duplicate keys by default. The client now passes
+  `allow_duplicate_key: true`, preserving json 2.x's last-one-wins
+  behavior, so a miner whose firmware repeats a key no longer raises
+  `JSON::ParserError` mid-poll.
+
+## [0.4.0] - 2026-04-25
+
+### Added
+- **`CgminerApiClient::AccessDeniedError`**, a subclass of `ApiError`
+  for the most commonly dispatched-on case (cgminer Code 45 + the
+  `access_denied?` local guard). Inherits from `ApiError` so existing
+  `rescue ApiError` clauses still catch it; callers wanting finer
+  dispatch use `rescue AccessDeniedError`. Constructor pins
+  `code: :access_denied` so the symbolic tag is consistent. The
+  wire-side `Miner#check_status` delegates to a new factory
+  `ApiError.for_status(c, msg)` that picks the right subclass
+  based on the integer Code.
+- **Structured error codes on `CgminerApiClient::ApiError`.** Two new
+  reader methods alongside the existing `#message`:
+  `#cgminer_code` (the integer Code from cgminer's STATUS hash —
+  e.g., `45` for access denied — or `nil` if the wire integer was
+  discarded, as happens when the `access_denied?` local guard's
+  call to `privileged` hits the wire and the rescue inside
+  `privileged` drops the integer before re-raising) and `#code`
+  (a symbolic tag derived from the integer via
+  `ApiError::CGMINER_CODES`, falling back to `:unknown` for codes
+  not in the map). Callers can now `case e.code; when :access_denied`
+  instead of parsing English error strings. **Prefer `e.code` for
+  dispatch over `e.cgminer_code`** — `cgminer_code` can be nil even
+  when the symbolic tag is set. The map is intentionally
+  conservative — `14 → :invalid_command`, `45 → :access_denied`,
+  the codes observed against real cgminer wire fixtures.
+  Backward-compatible: `raise ApiError, "msg"` still works and
+  `e.message` is unchanged.
+
+### Changed
+- `ApiError` constructor now validates `cgminer_code:` is `Integer`
+  or `nil` and `code:` is `Symbol`, `String`, or `nil`. Bad input
+  raises `ArgumentError` with a clear message instead of silently
+  producing `code: :unknown` (string `cgminer_code`) or
+  `NoMethodError` deep in the constructor (`code: 42`). Wire-side
+  callers go through `ApiError.for_status` which coerces a
+  non-numeric Code to `nil` so dispatch falls through to `:unknown`.
+- **`docs/logging.md`** — short stub stating that `cgminer_api_client`
+  is intentionally silent: no `Logger` module, no structured log
+  events. The library raises on failure and returns result objects
+  on success; callers (`cgminer_monitor`, `cgminer_manager`, the
+  operator CLIs) own the log call sites. Points at
+  `cgminer_monitor/docs/log_schema.md` for the cross-repo schema
+  contract and names the events (`poll.miner_failed`,
+  `poll.unexpected_error`) that surface api_client exception classes.
+- **`bundle-audit` in CI** (`.github/workflows/ci.yml`). New `audit`
+  job runs `bundle exec bundle-audit check --update` on every push
+  and PR, gating merges on known CVEs in `Gemfile.lock`. Advisory
+  DB is refreshed on each run from `rubysec/ruby-advisory-db`. Also
+  available locally as `bundle exec rake audit`.
+- **Dependabot config** (`.github/dependabot.yml`). Weekly bump PRs
+  for Bundler and GitHub Actions, with `open-pull-requests-limit: 3`
+  per ecosystem. `versioning-strategy: lockfile-only` on bundler, so
+  Gemfile / gemspec constraints are never auto-widened — humans
+  widen `~>` bounds intentionally. Targets `develop` so bumps flow
+  through the normal release cycle alongside feature work.
+- **`-v` / `--verbose` flag on the `cgminer_api_client` CLI.** Logs the
+  JSON request and raw response to stderr, one line each, with a
+  `host:port` prefix so multi-miner fan-out output stays grep-able. The
+  formatted result still goes to stdout unchanged. Parsed via
+  `OptionParser#permute!`, so the flag works before or after the
+  command. Passwords in `addpool`, `setconfig`, `ascset`, and `pgaset`
+  are replaced with `[REDACTED]` in the log output (wire bytes are
+  unaffected).
+- **`on_wire:` kwarg on `Miner#initialize` and `MinerPool#initialize`.**
+  Library-level hook used by the CLI's `-v` flag. Accepts a Proc of
+  shape `(direction, host, port, payload)` where direction is
+  `:request`, `:response`, or `:response_repaired`. Default `nil` is a
+  no-op; library code does not write to stderr itself.
+
+### Changed
+- **`Miner::Commands::Privileged#access_denied?`** now raises
+  `CgminerApiClient::ApiError` with message `'access denied'`
+  instead of a bare `RuntimeError` with message `'access_denied'`.
+  Callers using `rescue CgminerApiClient::Error` or
+  `rescue StandardError` are unaffected; only code that specifically
+  pattern-matched on `RuntimeError` from a privileged command on an
+  unprivileged miner needs to update.
+- **`MinerPool#load_miners!`** now raises `CgminerApiClient::Error`
+  (was `RuntimeError`) when `config/miners.yml` is missing. Existing
+  `rescue StandardError` clauses still work.
+- Test-support code (FakeCgminer, CgminerFixtures) extracted to the
+  shared `cgminer_test_support` gem. Spec references now use
+  `CgminerTestSupport::FakeCgminer` and
+  `CgminerTestSupport::Fixtures::SUMMARY` etc. `script/fake_cgminer`
+  is now a thin shim that delegates to `bundle exec fake_cgminer`;
+  operator muscle memory unchanged.
+
+### Fixed
+- **`MinerPool` no longer silently defaults a miners.yml entry
+  missing `host` to `CgminerApiClient.default_host`.** A typo'd
+  config entry like `{port: 4028}` used to quietly produce a Miner
+  pointing at `127.0.0.1`; now raises
+  `CgminerApiClient::Error "config/miners.yml: entry N is missing 'host'"`
+  on `MinerPool.new`.
+
 ## [0.3.0] - 2026-04-07
 
 ### Removed

data/README.md

@@ -2,7 +2,7 @@
 
 [![CI](https://github.com/jramos/cgminer_api_client/actions/workflows/ci.yml/badge.svg)](https://github.com/jramos/cgminer_api_client/actions/workflows/ci.yml)
 
-A gem that allows sending API commands to a pool of [cgminer](https://github.com/ckolivas/cgminer) instances.
+A gem that allows sending API commands to a pool of [cgminer](https://github.com/ckolivas/cgminer) instances. Ships as both a Ruby library and a CLI (`cgminer_api_client <command>`). Zero runtime dependencies beyond the Ruby standard library.
 
 ## Requirements
 
@@ -131,12 +131,54 @@ distinct conditions, unlike in 0.2.x where they were conflated.
 pool.restart      # PoolResult of per-miner outcomes
 ```
 
+### Errors
+
+All gem-specific errors descend from `CgminerApiClient::Error < StandardError`:
+
+-   `CgminerApiClient::ConnectionError` — transport-level: the miner
+    was unreachable (DNS failure, connection refused, etc.).
+-   `CgminerApiClient::TimeoutError` — a `ConnectionError` subclass
+    for connect timeouts specifically.
+-   `CgminerApiClient::ApiError` — protocol-level: the miner answered
+    and returned a `STATUS=E`/`F` response.
+
+`rescue CgminerApiClient::Error` catches everything gem-specific.
+`rescue CgminerApiClient::ConnectionError` catches both generic
+transport failures and connect timeouts. A `MinerPool` query never
+raises per-miner errors — they land on the corresponding
+`MinerResult.failure` inside the returned `PoolResult`.
+
 ## CLI Usage
 
 API commands can be sent to your miner pool from the command line.
 
     $ cgminer_api_client <command> (<arguments>)
 
+### Exit Codes and Streams
+
+-   exit `0` — at least one miner's command succeeded.
+-   exit `1` — every miner failed, or a top-level exception bubbled up.
+-   exit `64` — unknown command or missing command argument (`EX_USAGE`).
+
+Per-miner responses are printed to stdout with a `host:port:` header.
+Per-miner errors are printed to stderr as
+`host:port: ErrorClass: message`. Set `DEBUG=1` to also print full
+backtraces for any top-level exception:
+
+    $ DEBUG=1 cgminer_api_client summary
+
+Pass `-v` / `--verbose` to log the JSON request and raw response to
+stderr for wire-level debugging. Each line carries a `host:port`
+prefix so fan-out across multiple miners stays grep-able:
+
+    $ cgminer_api_client -v summary
+    >>> 10.0.0.1:4028 {"command":"summary"}
+    <<< 10.0.0.1:4028 {"STATUS":[{"STATUS":"S",...}],"SUMMARY":[...]}
+
+Password-bearing arguments to `addpool`, `setconfig`, `ascset`, and
+`pgaset` are replaced with `[REDACTED]` in the log output (the real
+value is still sent on the wire).
+
 ### Commands & Arguments
 
 #### Read-Only
@@ -201,6 +243,13 @@ The following privileged miner and pool commands are currently available:
 
 Any cgminer API commands not explictly defined above are implemented using `method_missing`. A complete list of available API commands and options can be found in the [cgminer API-README](https://github.com/ckolivas/cgminer/blob/master/API-README).
 
+## Further Reading
+
+-   [`CHANGELOG.md`](CHANGELOG.md) — release history and the 0.2.x → 0.3.0 migration guide.
+-   [`AGENTS.md`](AGENTS.md) — context for AI coding assistants; also a useful conventions-and-extension guide for human contributors.
+-   [`docs/`](docs/) — topic-split deep dives on architecture, components, interfaces, data models, workflows, and dependencies. Start with [`docs/index.md`](docs/index.md).
+-   [cgminer API-README](https://github.com/ckolivas/cgminer/blob/master/API-README) — upstream documentation for the JSON API surface this gem wraps.
+
 ## Contributing
 
 1.  Fork it ( <https://github.com/jramos/cgminer_api_client/fork> )

data/bin/cgminer_api_client

@@ -5,20 +5,62 @@ $LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../lib/")
 
 require 'cgminer_api_client'
 require 'pp'
+require 'optparse'
+
+# permute! (rather than order!) lets a flag appear after the command —
+# `cgminer_api_client summary -v` works the same as `-v summary`.
+verbose = false
+begin
+  OptionParser.new do |opts|
+    opts.banner = 'USAGE: cgminer_api_client [-v|--verbose] command (arguments)'
+    opts.on('-v', '--verbose', 'Log JSON request and raw response to stderr') do
+      verbose = true
+    end
+  end.permute!(ARGV)
+rescue OptionParser::ParseError => e
+  warn "cgminer_api_client: #{e.message}"
+  warn 'USAGE: cgminer_api_client [-v|--verbose] command (arguments)'
+  exit 64 # EX_USAGE
+end
 
 command = ARGV.shift&.to_sym
 commands = CgminerApiClient::Miner::Commands.instance_methods
 
 unless command && commands.include?(command)
-  warn 'USAGE: cgminer_api_client command (arguments)'
+  warn 'USAGE: cgminer_api_client [-v|--verbose] command (arguments)'
   warn "commands: #{commands.sort.join(', ')}"
   warn ''
   warn 'Set DEBUG=1 to see full backtraces on errors.'
   exit 64 # EX_USAGE
 end
 
+# `MinerPool` fans out across miners in separate threads; Ruby's
+# `warn` / `$stderr.write` is not atomic across threads for
+# arbitrary-length payloads, so multi-miner fan-out can interleave
+# mid-JSON without a mutex. The mutex also keeps a request/response
+# pair contiguous. The host:port prefix lets operators grep a single
+# miner out of the mixed stream.
+on_wire = nil
+if verbose
+  wire_mutex = Mutex.new
+  wire_prefix = {
+    request: '>>>',
+    response: '<<<',
+    response_repaired: '<<< (repaired)'
+  }.freeze
+  on_wire = lambda do |direction, host, port, payload|
+    wire_mutex.synchronize do
+      warn "#{wire_prefix[direction]} #{host}:#{port} #{payload}"
+    end
+  rescue Errno::EPIPE, IOError
+    # stderr was closed mid-run (piped through a command that exited, etc.).
+    # Best-effort logging must not take down the query fan-out.
+    nil
+  end
+end
+
 begin
-  pool = CgminerApiClient::MinerPool.new
+  pool = CgminerApiClient::MinerPool.new(on_wire: on_wire)
   result = ARGV.empty? ? pool.query(command) : pool.query(command, *ARGV)
 
   result.each do |r|

data/lib/cgminer_api_client/errors.rb

@@ -19,5 +19,76 @@ module CgminerApiClient
   # Raised when the miner returned a response whose STATUS field
   # indicates an error (cgminer status code 'E' or 'F'). The message
   # contains the cgminer code and message verbatim.
-  class ApiError < Error; end
+  #
+  # Carries two structured fields for dispatch: callers `case e.code`
+  # instead of parsing English messages. The integer (#cgminer_code)
+  # is preserved verbatim from cgminer; the symbol (#code) is
+  # best-effort — cgminer's MSG enum names are stable but the
+  # integers occasionally shift between firmware versions, so add a
+  # row to CGMINER_CODES when you find a wire-observed integer worth
+  # dispatching on.
+  #
+  # Prefer #code for dispatch over #cgminer_code: paths that raise
+  # without a wire integer (the access_denied? local guard's call
+  # to #privileged hits the wire, but the rescue inside #privileged
+  # drops the integer) leave #cgminer_code nil while still setting
+  # #code consistently.
+  #
+  # Backward compatibility: `raise ApiError, "msg"` keeps working
+  # and #message is unchanged at every emission site.
+  class ApiError < Error
+    CGMINER_CODES = {
+      14 => :invalid_command,
+      45 => :access_denied
+    }.freeze
+
+    attr_reader :cgminer_code, :code
+
+    # Factory used at the wire-side emission point in Miner#check_status.
+    # Picks AccessDeniedError when the cgminer integer maps to
+    # :access_denied so callers can `rescue AccessDeniedError` for
+    # the most commonly dispatched-on case; falls back to ApiError
+    # for everything else. Wire boundary stays best-effort: a
+    # non-numeric Code coerces to nil and the symbolic tag becomes
+    # :unknown rather than raising mid-poll.
+    def self.for_status(status_code, message)
+      cgminer_code = Integer(status_code, exception: false)
+      klass = CGMINER_CODES[cgminer_code] == :access_denied ? AccessDeniedError : ApiError
+      klass.new("#{status_code}: #{message}", cgminer_code: cgminer_code)
+    end
+
+    def initialize(message = nil, cgminer_code: nil, code: nil)
+      # Fail loud at the library boundary on bad input. Without these
+      # guards, cgminer_code: "45" or 45.0 silently produces code:
+      # :unknown (CGMINER_CODES uses integer keys), and code: 42 raises
+      # NoMethodError on .to_sym deep in the constructor — both
+      # opaque failure modes. Wire-side callers that want best-effort
+      # Integer coercion go through ApiError.for_status.
+      unless cgminer_code.nil? || cgminer_code.is_a?(Integer)
+        raise ArgumentError,
+              "cgminer_code must be Integer or nil, got #{cgminer_code.class}: #{cgminer_code.inspect}"
+      end
+      unless code.nil? || code.is_a?(Symbol) || code.is_a?(String)
+        raise ArgumentError,
+              "code must be Symbol, String, or nil, got #{code.class}: #{code.inspect}"
+      end
+
+      super(message)
+      @cgminer_code = cgminer_code
+      @code = (code || CGMINER_CODES[cgminer_code] || :unknown).to_sym
+    end
+  end
+
+  # Specific subclass for cgminer's "access denied" response (STATUS=E
+  # Code 45) and the gem's own #access_denied? local guard. Inherits
+  # from ApiError so existing `rescue ApiError` clauses still catch
+  # it; callers wanting finer dispatch use `rescue AccessDeniedError`
+  # instead of `case e.code; when :access_denied`. Constructor pins
+  # code: :access_denied so the symbolic tag is consistent regardless
+  # of which call site raised.
+  class AccessDeniedError < ApiError
+    def initialize(message = nil, cgminer_code: nil)
+      super(message, cgminer_code: cgminer_code, code: :access_denied)
+    end
+  end
 end

data/lib/cgminer_api_client/miner/commands.rb

@@ -186,7 +186,15 @@ module CgminerApiClient
         private
 
         def access_denied?
-          raise 'access_denied' unless privileged
+          # privileged calls query(:privileged), so the wire IS hit; if
+          # the miner answers with STATUS=E Code 45, check_status raises
+          # AccessDeniedError and privileged rescues + returns false,
+          # dropping the cgminer integer in the rescue. Re-raise the
+          # specific subclass so callers can't tell which call path
+          # raised — `rescue AccessDeniedError` works identically for
+          # "real wire denied" and "guard-locally denied". cgminer_code
+          # stays nil here because it was discarded by privileged's rescue.
+          raise CgminerApiClient::AccessDeniedError, 'access denied' unless privileged
 
           false
         end

data/lib/cgminer_api_client/miner.rb

@@ -10,27 +10,29 @@ module CgminerApiClient
 
     attr_accessor :host, :port, :timeout
 
-    def initialize(host = nil, port = nil, timeout = nil)
+    # Positional parameters at these indices carry user-controlled values
+    # (pool passwords, setconfig values, ascset/pgaset option values)
+    # that should not appear verbatim in wire-logs. The wire request is
+    # never modified; only the copy passed to the on_wire callback is
+    # redacted. If a new privileged command is added that accepts a
+    # secret positional arg, register its index here.
+    REDACTED_PARAM_INDEX = {
+      addpool: 2,
+      setconfig: 1,
+      ascset: 2,
+      pgaset: 2
+    }.freeze
+
+    def initialize(host = nil, port = nil, timeout = nil, on_wire: nil)
       @host    = host    || CgminerApiClient.default_host
       @port    = port    || CgminerApiClient.default_port
       @timeout = timeout || CgminerApiClient.default_timeout
+      @on_wire = on_wire
     end
 
     def query(method, *params)
-      request = { command: method }
-
-      unless params.empty?
-        # cgminer uses comma to separate parameters, so any literal commas in
-        # parameter values must be backslash-escaped, and any literal
-        # backslashes must themselves be doubled. The block form of gsub is
-        # used so the replacement string isn't interpreted (in gsub's
-        # replacement-string syntax, '\\' means a single literal backslash,
-        # which makes the obvious gsub('\\', '\\\\') a silent no-op).
-        params = params.map { |p| p.to_s.gsub('\\') { '\\\\' }.gsub(',') { '\\,' } }
-        request[:parameter] = params.join(',')
-      end
-
-      response = perform_request(request)
+      request, loggable_request = build_requests(method, params)
+      response = perform_request(request, loggable_request: loggable_request)
       data = sanitized(response)
       method.to_s.match?('\+') ? data : data[method.to_sym]
     end
@@ -60,21 +62,77 @@ module CgminerApiClient
 
     private
 
-    def perform_request(request)
+    def build_requests(method, params)
+      return [{ command: method }, { command: method }] if params.empty?
+
+      escaped          = params.map { |p| escape_param(p) }
+      loggable_escaped = redact_params(method, params).map { |p| escape_param(p) }
+
+      [
+        { command: method, parameter: escaped.join(',') },
+        { command: method, parameter: loggable_escaped.join(',') }
+      ]
+    end
+
+    # cgminer uses comma to separate parameters, so any literal commas in
+    # parameter values must be backslash-escaped, and any literal
+    # backslashes must themselves be doubled. The block form of gsub is
+    # used so the replacement string isn't interpreted (in gsub's
+    # replacement-string syntax, '\\' means a single literal backslash,
+    # which makes the obvious gsub('\\', '\\\\') a silent no-op).
+    def escape_param(param)
+      param.to_s.gsub('\\') { '\\\\' }.gsub(',') { '\\,' }
+    end
+
+    def redact_params(method, params)
+      idx = REDACTED_PARAM_INDEX[method.to_sym]
+      return params unless idx && params[idx]
+
+      redacted = params.dup
+      redacted[idx] = '[REDACTED]'
+      redacted
+    end
+
+    # on_wire is best-effort telemetry — a callback that raises must
+    # not break the real query path or leak the connection. Operators
+    # who suspect their callback is broken can remove -v to isolate.
+    def safe_on_wire(direction, payload)
+      return unless @on_wire
+
+      @on_wire.call(direction, @host, @port, payload)
+    rescue StandardError
+      nil
+    end
+
+    def perform_request(request, loggable_request: request)
       begin
         s = open_socket(@host, @port, @timeout)
       rescue StandardError => e
         raise ConnectionError, "Connection to #{@host}:#{@port} failed: #{e.class}: #{e.message}"
       end
 
+      safe_on_wire(:request, loggable_request.to_json)
       s.write(request.to_json)
       response = s.read.strip.chars.map { |c| c.ord >= 32 ? c : format('\\u%04x', c.ord) }.join
       s.close
+      safe_on_wire(:response, response)
+
+      # Legacy defensive repair for malformed multi-object responses. We
+      # haven't reproduced a case where this actually fires on modern
+      # cgminer; see spec/support/cgminer_fixtures.rb for commentary.
+      # Keep in place until we can confirm it isn't needed on real traffic.
+      # If the repair ever fires, emit an additional :response_repaired
+      # callback so a broken-looking JSON log isn't mysterious.
+      repaired = response.gsub('}{', '}, {').gsub('[,{', '[ {')
+      if repaired != response
+        safe_on_wire(:response_repaired, repaired)
+        response = repaired
+      end
 
-      response.gsub! '}{', '}, {'
-      response.gsub! '[,{', '[ {'
-
-      data = JSON.parse(response)
+      # json 3.0 rejects duplicate keys by default; keep json 2.x's
+      # last-one-wins behavior since some cgminer forks repeat keys.
+      # Older json versions ignore the option.
+      data = JSON.parse(response, allow_duplicate_key: true)
 
       if request[:command].to_s.match?('\+')
         data.each_pair do |_command, response|
@@ -94,9 +152,12 @@ module CgminerApiClient
       msg    = status['Msg']
 
       # cgminer STATUS codes: S=Success (silent), I=Info, W=Warning,
-      # E=Error, F=Fatal. Errors and Fatals raise ApiError so callers
-      # can distinguish them from ConnectionError (transport-level
-      # failures).
+      # E=Error, F=Fatal. Errors and Fatals raise via ApiError.for_status
+      # which picks AccessDeniedError for Code 45 (so callers can
+      # `rescue AccessDeniedError`) and falls back to ApiError otherwise.
+      # The wire boundary stays best-effort — non-numeric Codes coerce
+      # to nil and the symbolic tag becomes :unknown rather than
+      # raising mid-poll.
       case sc
       when 'S'
         # no-op: success needs no notification
@@ -105,7 +166,7 @@ module CgminerApiClient
       when 'W'
         puts "Warning from API [#{c}]: #{msg}"
       else
-        raise ApiError, "#{c}: #{msg}"
+        raise ApiError.for_status(c, msg)
       end
     end
 

data/lib/cgminer_api_client/miner_pool.rb

@@ -6,7 +6,8 @@ module CgminerApiClient
 
     attr_accessor :miners
 
-    def initialize
+    def initialize(on_wire: nil)
+      @on_wire = on_wire
       load_miners!
     end
 
@@ -99,14 +100,20 @@ module CgminerApiClient
     end
 
     def load_miners!
-      raise 'Please create config/miners.yml' unless File.exist?('config/miners.yml')
+      raise CgminerApiClient::Error, 'Please create config/miners.yml' unless File.exist?('config/miners.yml')
 
       miners_config = YAML.safe_load_file('config/miners.yml')
-      @miners = miners_config.collect do |miner|
+      @miners = miners_config.each_with_index.map do |entry, index|
+        unless entry.is_a?(Hash) && entry['host']
+          raise CgminerApiClient::Error,
+                "config/miners.yml: entry #{index} is missing 'host'"
+        end
+
         CgminerApiClient::Miner.new(
-          miner['host'],
-          miner['port'],
-          miner['timeout']
+          entry['host'],
+          entry['port'],
+          entry['timeout'],
+          on_wire: @on_wire
         )
       end
     end

data/lib/cgminer_api_client/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CgminerApiClient
-  VERSION = "0.3.0"
+  VERSION = "0.4.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cgminer_api_client
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Justin Ramos