eaton 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 42cf738c337ad3fae01953c5e78003e8ed0c789146ee7b71bacaf8f3162b98ae
+  data.tar.gz: 0ebf36ddf22c38dea0a216777f8b04fb5da841648cbc1ccc0e4a83a8f45427ff
+SHA512:
+  metadata.gz: 5d342a6f0162da2fc073ccdb52f768a98daa7a6486b1c327c261b0a4b88e41c3d4d3763f55b02a14fb24e4393ff89d95f4d88f5c49ce728ad95c5fd78e98adbb
+  data.tar.gz: 26622a5ed0fcd33eb9249b25f92550b887f6844c528fd9641380782aabdbe3f4de5717020d6554d0212640b1aeffd6853963e6b3038c5757e3962e6245fbceed

data/CHANGELOG.md

@@ -0,0 +1,34 @@
+# Changelog
+
+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.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2025-01-20
+
+### Added
+- Initial release
+- OAuth2 bearer token authentication with Eaton PDU G4 devices
+- Power monitoring commands:
+  - `eaton power` - Overall power consumption
+  - `eaton outlets` - Per-outlet power monitoring
+  - `eaton branches` - Branch power distribution
+  - `eaton detailed` - Detailed power metrics
+  - `eaton info` - PDU device information
+  - `eaton auth` - Authentication testing
+- Smart filtering: text mode shows only active outlets/branches, JSON shows all
+- SSH tunneling support via custom host headers
+- Dual output formats: human-friendly text and machine-readable JSON
+- Ruby API for programmatic access
+- Support for 42 outlets and 6 branches
+- Metrics include: watts, voltage, current, power factor, frequency, load percentage
+
+### Features
+- Zero-dependency HTTP client (uses Ruby's Net::HTTP)
+- Automatic token management and session cleanup
+- Comprehensive error handling
+- CLI built with Thor
+- Compatible with Ruby 3.0+
+
+[0.1.0]: https://github.com/usiegj00/eaton/releases/tag/v0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jonathan Siegel
+
+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,269 @@
+# Eaton PDU Manager
+
+A Ruby gem and CLI for managing Eaton Rack PDU G4 devices via REST API. Provides comprehensive power monitoring and management capabilities.
+
+## Features
+
+- 🔌 **Power Monitoring**: Overall, per-outlet, and per-branch power consumption
+- 📊 **Detailed Metrics**: Voltage, current, power factor, frequency, load percentage
+- 🔄 **Smart Filtering**: Text mode shows only active outlets/branches, JSON mode shows all
+- 🔐 **OAuth2 Authentication**: Secure bearer token authentication
+- 🌐 **SSH Tunneling**: Support for SSH tunneled connections via custom host headers
+- 📝 **Dual Output**: Human-friendly text or machine-readable JSON
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'eaton'
+```
+
+Or install directly:
+
+```bash
+gem install eaton
+```
+
+For development:
+
+```bash
+git clone https://github.com/usiegj00/eaton.git
+cd eaton
+bundle install
+```
+
+## Quick Start
+
+```bash
+# Get overall power consumption
+eaton power \
+  --host pdu.example.com \
+  --username admin \
+  --password your_password
+
+# Get active outlets only (text mode)
+eaton outlets \
+  --host pdu.example.com \
+  --username admin \
+  --password your_password
+
+# Get all outlets as JSON
+eaton outlets \
+  --host pdu.example.com \
+  --username admin \
+  --password your_password \
+  --format json
+```
+
+## Commands
+
+All commands support these options:
+- `--host` - PDU hostname or IP (required)
+- `--port` - PDU port (default: 443)
+- `--username` - PDU username (required)
+- `--password` - PDU password (required)
+- `--host-header` - Custom Host header for SSH tunneling (optional)
+- `--verify-ssl` - Verify SSL certificates (default: false)
+- `--format` - Output format: `text` or `json` (default: text)
+
+### Available Commands
+
+| Command | Description |
+|---------|-------------|
+| `eaton auth` | Test authentication |
+| `eaton info` | Display PDU device information |
+| `eaton power` | Get overall power consumption (watts) |
+| `eaton outlets` | Get per-outlet power consumption |
+| `eaton branches` | Get per-branch power distribution |
+| `eaton detailed` | Get detailed power metrics |
+
+### Output Filtering
+
+**Text Mode** (default):
+- Shows only outlets/branches with active power draw
+- Clean, focused output for human reading
+
+**JSON Mode** (`--format json`):
+- Shows all outlets/branches regardless of state
+- Complete data for automation and monitoring systems
+
+## Usage Examples
+
+### Get PDU Information
+
+```bash
+eaton info --host pdu.example.com --username admin --password secret
+```
+
+Output:
+```
+PDU Device Information:
+============================================================
+id: 1
+name: PDU
+model: Eaton Rack PDU G4
+serial_number: ABC123
+vendor: Eaton
+firmware_version: 2.9.2
+status: in service
+health: ok
+nominal_power: 19800
+nominal_current: 55
+nominal_voltage: 208
+```
+
+### Monitor Overall Power
+
+```bash
+eaton power --host pdu.example.com --username admin --password secret
+```
+
+Output:
+```
+Overall Power:
+============================================================
+watts: 1542.3
+```
+
+### View Active Outlets
+
+```bash
+eaton outlets --host pdu.example.com --username admin --password secret
+```
+
+Shows only outlets currently drawing power.
+
+### Export All Outlets to JSON
+
+```bash
+eaton outlets \
+  --host pdu.example.com \
+  --username admin \
+  --password secret \
+  --format json > outlets.json
+```
+
+### SSH Tunneling
+
+When connecting through an SSH tunnel:
+
+```bash
+# SSH tunnel to remote PDU
+ssh -L 5000:192.168.1.100:443 user@jumphost
+
+# Connect via tunnel with custom host header
+eaton power \
+  --host localhost \
+  --port 5000 \
+  --username admin \
+  --password secret \
+  --host-header 192.168.1.100
+```
+
+## Ruby API
+
+Use the gem programmatically in your Ruby code:
+
+```ruby
+require 'eaton'
+
+# Create client
+client = Eaton::Client.new(
+  host: 'pdu.example.com',
+  username: 'admin',
+  password: 'secret',
+  verify_ssl: true
+)
+
+# Extend with power monitoring
+client.extend(Eaton::Power)
+
+# Get PDU info
+info = client.pdu_info
+puts "#{info[:model]} - #{info[:serial_number]}"
+
+# Get overall power
+power = client.overall_power
+puts "Current draw: #{power} watts"
+
+# Get active outlets
+outlets = client.outlet_power
+outlets.select { |o| o[:watts] > 0 }.each do |outlet|
+  puts "#{outlet[:name]}: #{outlet[:watts]}W"
+end
+
+# Get branch distribution
+branches = client.branch_power
+branches.each do |branch|
+  puts "#{branch[:name]}: #{branch[:current]}A @ #{branch[:voltage]}V"
+end
+
+# Clean up
+client.logout
+```
+
+## API Endpoints
+
+The gem interfaces with these REST API endpoints:
+
+- `/powerDistributions/1` - PDU device information
+- `/powerDistributions/1/inputs/1` - Overall power input
+- `/powerDistributions/1/outlets/{id}` - Individual outlet data
+- `/powerDistributions/1/branches/{id}` - Branch distribution data
+
+## Supported Devices
+
+Tested and verified with:
+- **Eaton Rack PDU G4**
+- Firmware: 2.9.2+
+- API: `/rest/mbdetnrs/2.0`
+
+Should work with other Eaton PDU models using the same API version.
+
+## Authentication
+
+Uses OAuth2 bearer token authentication:
+
+1. POST credentials to `/oauth2/token/`
+2. Receive access token
+3. Include token in `Authorization: Bearer {token}` header
+4. Token automatically managed and refreshed
+
+## Development
+
+```bash
+# Clone repository
+git clone https://github.com/usiegj00/eaton.git
+cd eaton
+
+# Install dependencies
+bundle install
+
+# Run tests
+bundle exec rspec
+
+# Install locally
+bundle exec rake install
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b feature/my-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin feature/my-feature`)
+5. Create a Pull Request
+
+## License
+
+MIT License - see LICENSE file for details
+
+## Support
+
+- Issues: https://github.com/usiegj00/eaton/issues
+- Documentation: https://github.com/usiegj00/eaton
+
+## Credits
+
+Developed for managing Eaton Rack PDU G4 devices via REST API.

data/Rakefile

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

data/exe/eaton

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "eaton"
+
+Eaton::CLI.start(ARGV)

data/lib/eaton/cli.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require "thor"
+require "json"
+
+module Eaton
+  class CLI < Thor
+    class_option :host, type: :string, required: true, desc: "PDU hostname or IP address"
+    class_option :port, type: :numeric, default: 443, desc: "PDU port (default: 443)"
+    class_option :username, type: :string, required: true, desc: "PDU username"
+    class_option :password, type: :string, required: true, desc: "PDU password"
+    class_option :verify_ssl, type: :boolean, default: false, desc: "Verify SSL certificates"
+    class_option :host_header, type: :string, desc: "Custom Host header (for SSH tunneling)"
+    class_option :format, type: :string, default: "text", enum: ["text", "json"], desc: "Output format"
+
+    desc "power", "Get overall power consumption in watts"
+    def power
+      with_client do |client|
+        power = client.overall_power
+        output_result("Overall Power", { watts: power })
+      end
+    end
+
+    desc "outlets", "Get per-outlet power consumption"
+    def outlets
+      with_client do |client|
+        outlets = client.outlet_power
+        # Filter out zero-power outlets in text mode
+        if options[:format] == "text"
+          outlets = outlets.select { |o| o[:watts] && o[:watts] > 0 }
+        end
+        output_result("Outlet Power", outlets)
+      end
+    end
+
+    desc "detailed", "Get detailed power information"
+    def detailed
+      with_client do |client|
+        info = client.detailed_power_info
+        # Filter outlets in text mode
+        if options[:format] == "text" && info[:outlets]
+          info[:outlets] = info[:outlets].select { |o| o[:watts] && o[:watts] > 0 }
+        end
+        output_result("Detailed Power Information", info)
+      end
+    end
+
+    desc "branches", "Get power consumption per branch"
+    def branches
+      with_client do |client|
+        branches = client.branch_power
+        # Filter out zero-current branches in text mode
+        if options[:format] == "text"
+          branches = branches.select { |b| b[:current] && b[:current] > 0 }
+        end
+        output_result("Branch Power", branches)
+      end
+    end
+
+    desc "info", "Display PDU device information"
+    def info
+      with_client do |client|
+        info = client.pdu_info
+        output_result("PDU Device Information", info)
+      end
+    end
+
+    desc "auth", "Test authentication with the PDU"
+    def auth
+      with_client do |client|
+        token = client.authenticate!
+        output_result("Authentication Test", {
+          status: "success",
+          token_present: !token.nil?,
+          token_length: token&.length
+        })
+      end
+    end
+
+    no_commands do
+      def with_client
+        client = Client.new(
+          host: options[:host],
+          port: options[:port],
+          username: options[:username],
+          password: options[:password],
+          verify_ssl: options[:verify_ssl],
+          host_header: options[:host_header]
+        )
+
+        # Mix in the Power module to add power monitoring methods
+        client.extend(Power)
+
+        yield client
+      rescue Client::AuthenticationError => e
+        error("Authentication failed: #{e.message}")
+      rescue Client::APIError => e
+        error("API error: #{e.message}")
+      rescue StandardError => e
+        error("Unexpected error: #{e.message}")
+      ensure
+        client&.logout
+      end
+
+      def output_result(title, data)
+        if options[:format] == "json"
+          puts JSON.pretty_generate(data)
+        else
+          output_text(title, data)
+        end
+      end
+
+      def output_text(title, data)
+        puts "\n#{title}:"
+        puts "=" * 60
+
+        case data
+        when Hash
+          output_hash(data)
+        when Array
+          data.each_with_index do |item, index|
+            puts "\n[#{index + 1}]"
+            output_hash(item) if item.is_a?(Hash)
+          end
+        else
+          puts data
+        end
+
+        puts
+      end
+
+      def output_hash(hash, indent = 0)
+        hash.each do |key, value|
+          prefix = "  " * indent
+          case value
+          when Hash
+            puts "#{prefix}#{key}:"
+            output_hash(value, indent + 1)
+          when Array
+            puts "#{prefix}#{key}:"
+            value.each_with_index do |item, index|
+              if item.is_a?(Hash)
+                puts "#{prefix}  [#{index}]:"
+                output_hash(item, indent + 2)
+              else
+                puts "#{prefix}  - #{item}"
+              end
+            end
+          else
+            puts "#{prefix}#{key}: #{value}"
+          end
+        end
+      end
+
+      def error(message)
+        STDERR.puts "ERROR: #{message}"
+        exit 1
+      end
+    end
+  end
+end

data/lib/eaton/client.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+require "openssl"
+
+module Eaton
+  class Client
+    class AuthenticationError < StandardError; end
+    class APIError < StandardError; end
+
+    attr_reader :host, :username, :base_url
+
+    def initialize(host:, username:, password:, port: 443, verify_ssl: false, host_header: nil)
+      @host = host
+      @username = username
+      @password = password
+      @port = port
+      @verify_ssl = verify_ssl
+      @host_header = host_header || host
+      @base_path = "/rest/mbdetnrs/2.0"
+      @token = nil
+      @session = nil
+    end
+
+    def authenticate!
+      request = Net::HTTP::Post.new("#{@base_path}/oauth2/token/")
+      add_browser_headers(request)
+      request.body = JSON.generate(username: @username, password: @password)
+
+      response = execute_request(request)
+
+      if response.code.to_i.between?(200, 299)
+        data = JSON.parse(response.body)
+        @token = data["access_token"]
+        @session = data["session"]
+        @token
+      else
+        raise AuthenticationError, "Authentication failed: #{response.body}"
+      end
+    rescue JSON::ParserError => e
+      raise AuthenticationError, "Invalid response from server: #{e.message}"
+    end
+
+    def authenticated?
+      !@token.nil?
+    end
+
+    def get(path)
+      authenticate! unless authenticated?
+
+      request = Net::HTTP::Get.new("#{@base_path}#{path}")
+      add_auth_headers(request)
+
+      handle_response(execute_request(request))
+    end
+
+    def post(path, data = {})
+      authenticate! unless authenticated?
+
+      request = Net::HTTP::Post.new("#{@base_path}#{path}")
+      add_auth_headers(request)
+      request.body = data.to_json
+
+      handle_response(execute_request(request))
+    end
+
+    def logout
+      return unless authenticated?
+
+      begin
+        delete(@session) if @session
+      rescue APIError
+        # Session might already be expired or deleted, ignore
+      ensure
+        @token = nil
+        @session = nil
+      end
+    end
+
+    private
+
+    def http_connection
+      @http_connection ||= begin
+        http = Net::HTTP.new(@host, @port)
+        http.use_ssl = true
+        http.verify_mode = @verify_ssl ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+        http
+      end
+    end
+
+    def execute_request(request)
+      http_connection.request(request)
+    end
+
+    def add_browser_headers(request)
+      request["Content-Type"] = "application/json"
+      request["Host"] = @host_header
+      request["Sec-Fetch-Mode"] = "cors"
+      request["User-Agent"] = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36"
+      request["Origin"] = "https://#{@host_header}"
+      request["Sec-Fetch-Site"] = "same-origin"
+    end
+
+    def add_auth_headers(request)
+      request["Content-Type"] = "application/json"
+      request["Authorization"] = "Bearer #{@token}"
+      request["Host"] = @host_header
+    end
+
+    def delete(path)
+      request = Net::HTTP::Delete.new("#{@base_path}#{path}")
+      add_auth_headers(request)
+
+      handle_response(execute_request(request))
+    end
+
+    def handle_response(response)
+      status_code = response.code.to_i
+
+      case status_code
+      when 200..299
+        begin
+          JSON.parse(response.body)
+        rescue JSON::ParserError
+          response.body
+        end
+      when 401, 403
+        # Token might have expired, clear it and let caller retry
+        @token = nil
+        raise AuthenticationError, "Authentication failed or token expired"
+      else
+        error_message = begin
+          data = JSON.parse(response.body)
+          data["description"] || response.body
+        rescue
+          response.body
+        end
+        raise APIError, "API error (#{status_code}): #{error_message}"
+      end
+    end
+  end
+end

data/lib/eaton/power.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Eaton
+  module Power
+    # Get overall power consumption for the PDU
+    # Returns power in watts
+    def overall_power
+      data = get("/powerDistributions/1/inputs/1")
+      data.dig("measures", "activePower")
+    end
+
+    # Get per-outlet power consumption
+    # Returns an array of hashes with outlet info and power in watts
+    def outlet_power
+      # Get list of outlets
+      outlets_list = get("/powerDistributions/1/outlets")
+      member_count = outlets_list["members@count"] || 0
+
+      return [] if member_count.zero?
+
+      # Get data for each outlet
+      outlets = []
+      outlets_list["members"].each do |member|
+        outlet_id = member["@id"].split("/").last
+        outlet_data = get("/powerDistributions/1/outlets/#{outlet_id}")
+
+        outlets << {
+          id: outlet_data["id"],
+          name: outlet_data.dig("identification", "friendlyName") || "Outlet #{outlet_id}",
+          physical_name: outlet_data.dig("identification", "physicalName"),
+          watts: outlet_data.dig("measures", "activePower"),
+          current: outlet_data.dig("measures", "current"),
+          voltage: nil, # Outlets don't report voltage individually
+          power_factor: outlet_data.dig("measures", "powerFactor"),
+          state: outlet_data.dig("status", "switchedOn") ? "on" : "off",
+          switched_on: outlet_data.dig("status", "switchedOn")
+        }
+      end
+
+      outlets
+    end
+
+    # Get detailed power information including voltage, current, and power factor
+    def detailed_power_info
+      input_data = get("/powerDistributions/1/inputs/1")
+
+      {
+        overall: {
+          watts: input_data.dig("measures", "activePower"),
+          apparent_power: input_data.dig("measures", "apparentPower"),
+          reactive_power: input_data.dig("measures", "reactivePower"),
+          frequency: input_data.dig("measures", "frequency"),
+          power_factor: input_data.dig("measures", "powerFactor"),
+          percent_load: input_data.dig("measures", "percentLoad"),
+          cumulated_energy: input_data.dig("measures", "cumulatedEnergy"),
+          partial_energy: input_data.dig("measures", "partialEnergy")
+        },
+        outlets: outlet_power
+      }
+    end
+
+    # Get branch power information
+    # Returns an array of branch power data
+    def branch_power
+      branches_list = get("/powerDistributions/1/branches")
+      member_count = branches_list["members@count"] || 0
+
+      return [] if member_count.zero?
+
+      branches = []
+      branches_list["members"].each do |member|
+        branch_id = member["@id"].split("/").last
+        branch_data = get("/powerDistributions/1/branches/#{branch_id}")
+
+        branches << {
+          id: branch_data["id"],
+          name: branch_data.dig("identification", "friendlyName") || "Branch #{branch_id}",
+          physical_name: branch_data.dig("identification", "physicalName"),
+          watts: branch_data.dig("measures", "activePower"),
+          current: branch_data.dig("measures", "current"),
+          voltage: branch_data.dig("measures", "voltage"),
+          power_factor: branch_data.dig("measures", "powerFactor")
+        }
+      end
+
+      branches
+    end
+
+    # Get PDU information
+    def pdu_info
+      data = get("/powerDistributions/1")
+
+      {
+        id: data["id"],
+        name: data.dig("identification", "friendlyName"),
+        model: data.dig("identification", "model"),
+        serial_number: data.dig("identification", "serialNumber"),
+        part_number: data.dig("identification", "partNumber"),
+        vendor: data.dig("identification", "vendor"),
+        firmware_version: data.dig("identification", "firmwareVersion"),
+        status: data.dig("status", "operating"),
+        health: data.dig("status", "health"),
+        nominal_power: data.dig("specifications", "activePower", "nominal"),
+        nominal_current: data.dig("specifications", "current", "nominal"),
+        nominal_voltage: data.dig("specifications", "voltage", "nominal")
+      }
+    end
+  end
+end

data/lib/eaton/version.rb

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

data/lib/eaton.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "eaton/version"
+require_relative "eaton/client"
+require_relative "eaton/power"
+require_relative "eaton/cli"
+
+module Eaton
+  class Error < StandardError; end
+end

data/sig/pdu_manager.rbs

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

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: eaton
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jonathan Siegel
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-10-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Comprehensive power monitoring and management for Eaton Rack PDU G4 devices.
+  Features include overall power consumption, per-outlet monitoring, branch distribution,
+  detailed metrics (voltage, current, power factor), OAuth2 authentication, and SSH
+  tunneling support.
+email:
+- jonathan@example.com
+executables:
+- eaton
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- Rakefile
+- exe/eaton
+- lib/eaton.rb
+- lib/eaton/cli.rb
+- lib/eaton/client.rb
+- lib/eaton/power.rb
+- lib/eaton/version.rb
+- sig/pdu_manager.rbs
+homepage: https://github.com/usiegj00/eaton
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/usiegj00/eaton
+  source_code_uri: https://github.com/usiegj00/eaton
+  bug_tracker_uri: https://github.com/usiegj00/eaton/issues
+  changelog_uri: https://github.com/usiegj00/eaton/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/usiegj00/eaton
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Ruby gem and CLI for managing Eaton Rack PDU G4 devices via REST API
+test_files: []