keenetic 0.2.0 → 1.0.0

data/lib/keenetic/resources/system.rb

@@ -138,8 +138,142 @@ module Keenetic
         normalize_license(response)
       end
 
+      # Reboot the router.
+      #
+      # == Keenetic API Request
+      #   POST /rci/system/reboot
+      #   Body: {}
+      #
+      # == Warning
+      # This will immediately restart the router. All active connections
+      # will be dropped and the router will be unavailable for 1-2 minutes.
+      #
+      # @return [Hash, nil] API response
+      # @example
+      #   client.system.reboot
+      #
+      def reboot
+        post('/rci/system/reboot', {})
+      end
+
+      # Factory reset the router.
+      #
+      # == Keenetic API Request
+      #   POST /rci/system/default
+      #   Body: {}
+      #
+      # == Warning
+      # This will erase ALL configuration and restore factory defaults.
+      # The router will reboot and you will lose access until you
+      # reconfigure it. Use with extreme caution!
+      #
+      # @return [Hash, nil] API response
+      # @example
+      #   client.system.factory_reset
+      #
+      def factory_reset
+        post('/rci/system/default', {})
+      end
+
+      # Check for available firmware updates.
+      #
+      # == Keenetic API Request
+      #   GET /rci/show/system/update
+      #
+      # == Response Fields
+      #   - available: Whether an update is available
+      #   - version: Available firmware version
+      #   - current: Current firmware version
+      #   - channel: Update channel (stable, preview)
+      #
+      # @return [Hash] Update availability information
+      # @example
+      #   update_info = client.system.check_updates
+      #   # => { available: true, version: "4.2.0", current: "4.1.0", ... }
+      #
+      def check_updates
+        response = get('/rci/show/system/update')
+        normalize_update_info(response)
+      end
+
+      # Apply available firmware update.
+      #
+      # == Keenetic API Request
+      #   POST /rci/system/update
+      #   Body: {}
+      #
+      # == Warning
+      # This will download and install the latest firmware update.
+      # The router will reboot automatically after the update is applied.
+      # Do not power off the router during the update process!
+      #
+      # @return [Hash, nil] API response
+      # @example
+      #   client.system.apply_update
+      #
+      def apply_update
+        post('/rci/system/update', {})
+      end
+
+      # Control LED mode on the router.
+      #
+      # == Keenetic API Request
+      #   POST /rci/system/led
+      #   Body: { "mode": "on" | "off" | "auto" }
+      #
+      # @param mode [String] LED mode: "on", "off", or "auto"
+      # @return [Hash, nil] API response
+      # @raise [ArgumentError] if mode is invalid
+      #
+      # @example Turn off LEDs
+      #   client.system.set_led_mode('off')
+      #
+      # @example Set to automatic
+      #   client.system.set_led_mode('auto')
+      #
+      def set_led_mode(mode)
+        valid_modes = %w[on off auto]
+        unless valid_modes.include?(mode)
+          raise ArgumentError, "Invalid LED mode: #{mode}. Valid modes: #{valid_modes.join(', ')}"
+        end
+
+        post('/rci/system/led', { 'mode' => mode })
+      end
+
+      # Get button configuration.
+      #
+      # == Keenetic API Request
+      #   GET /rci/show/button
+      #
+      # Returns information about physical buttons on the router
+      # and their configured actions.
+      #
+      # @return [Hash] Button configuration
+      # @example
+      #   buttons = client.system.button_config
+      #   # => { wifi: { action: "toggle" }, fn: { action: "wps" } }
+      #
+      def button_config
+        response = get('/rci/show/button')
+        normalize_button_config(response)
+      end
+
       private
 
+      def normalize_update_info(response)
+        return {} unless response.is_a?(Hash)
+
+        result = deep_normalize_keys(response)
+        normalize_booleans(result, %i[available downloading])
+        result
+      end
+
+      def normalize_button_config(response)
+        return {} unless response.is_a?(Hash)
+
+        deep_normalize_keys(response)
+      end
+
       def normalize_resources(response)
         return {} unless response.is_a?(Hash)
 

data/lib/keenetic/resources/usb.rb

@@ -0,0 +1,135 @@
+module Keenetic
+  module Resources
+    # USB resource for managing USB devices and storage.
+    #
+    # == API Endpoints Used
+    #
+    # === Reading USB Devices
+    #   GET /rci/show/usb
+    #   Returns: Connected USB devices
+    #
+    # === Reading Storage/Media
+    #   GET /rci/show/media
+    #   Returns: Mounted storage partitions
+    #
+    # === Safely Eject USB
+    #   POST /rci/usb/eject
+    #   Body: { port }
+    #
+    class Usb < Base
+      # Get connected USB devices.
+      #
+      # == Keenetic API Request
+      #   GET /rci/show/usb
+      #
+      # == Response Fields (per device)
+      #   - port: USB port number
+      #   - manufacturer: Device manufacturer
+      #   - product: Product name
+      #   - serial: Serial number
+      #   - class: USB device class
+      #   - speed: USB speed
+      #   - connected: Currently connected
+      #
+      # @return [Array<Hash>] List of USB devices
+      # @example
+      #   devices = client.usb.devices
+      #   # => [{ port: 1, manufacturer: "SanDisk", product: "USB Flash", ... }]
+      #
+      def devices
+        response = get('/rci/show/usb')
+        normalize_devices(response)
+      end
+
+      # Get mounted storage partitions.
+      #
+      # == Keenetic API Request
+      #   GET /rci/show/media
+      #
+      # == Response Fields (per partition)
+      #   - name: Device name
+      #   - label: Volume label
+      #   - uuid: Volume UUID
+      #   - fs: Filesystem type
+      #   - mountpoint: Mount path
+      #   - total: Total bytes
+      #   - used: Used bytes
+      #   - free: Free bytes
+      #
+      # @return [Array<Hash>] List of storage partitions
+      # @example
+      #   media = client.usb.media
+      #   # => [{ name: "sda1", label: "USB_DRIVE", fs: "ext4", total: 32000000000, ... }]
+      #
+      def media
+        response = get('/rci/show/media')
+        normalize_media(response)
+      end
+
+      # Alias for media
+      alias storage media
+
+      # Safely eject a USB device.
+      #
+      # == Keenetic API Request
+      #   POST /rci/usb/eject
+      #   Body: { "port": 1 }
+      #
+      # @param port [Integer] USB port number to eject
+      # @return [Hash, nil] API response
+      #
+      # @example
+      #   client.usb.eject(port: 1)
+      #
+      def eject(port:)
+        post('/rci/usb/eject', { 'port' => port })
+      end
+
+      private
+
+      def normalize_devices(response)
+        devices_data = case response
+                       when Array
+                         response
+                       when Hash
+                         response['device'] || response['devices'] || []
+                       else
+                         []
+                       end
+
+        return [] unless devices_data.is_a?(Array)
+
+        devices_data.map { |device| normalize_device(device) }.compact
+      end
+
+      def normalize_device(data)
+        return nil unless data.is_a?(Hash)
+
+        result = deep_normalize_keys(data)
+        normalize_booleans(result, %i[connected])
+        result
+      end
+
+      def normalize_media(response)
+        media_data = case response
+                     when Array
+                       response
+                     when Hash
+                       response['media'] || response['partition'] || []
+                     else
+                       []
+                     end
+
+        return [] unless media_data.is_a?(Array)
+
+        media_data.map { |partition| normalize_partition(partition) }.compact
+      end
+
+      def normalize_partition(data)
+        return nil unless data.is_a?(Hash)
+
+        deep_normalize_keys(data)
+      end
+    end
+  end
+end

data/lib/keenetic/resources/users.rb

@@ -0,0 +1,92 @@
+module Keenetic
+  module Resources
+    # Users resource for managing router user accounts.
+    #
+    # == API Endpoints Used
+    #
+    # === List Users
+    #   GET /rci/show/user
+    #
+    # === Create User
+    #   POST /rci/user
+    #
+    # === Delete User
+    #   POST /rci/user with { "name": "...", "no": true }
+    #
+    # == User Tags (permissions)
+    #   - http: Web interface access
+    #   - cli: CLI/Telnet access
+    #   - cifs: File sharing access
+    #   - ftp: FTP access
+    #   - vpn: VPN access
+    #
+    class Users < Base
+      # List all users.
+      #
+      # @return [Array<Hash>] List of users
+      # @example
+      #   users = client.users.all
+      #
+      def all
+        response = get('/rci/show/user')
+        normalize_users(response)
+      end
+
+      # Find a user by name.
+      #
+      # @param name [String] User name
+      # @return [Hash, nil] User data or nil
+      #
+      def find(name)
+        all.find { |u| u[:name] == name }
+      end
+
+      # Create a new user.
+      #
+      # @param name [String] User name
+      # @param password [String] User password
+      # @param tag [Array<String>] Permission tags (http, cli, cifs, ftp, vpn)
+      # @return [Hash, nil] API response
+      # @example
+      #   client.users.create(name: 'guest', password: 'guestpass', tag: ['http', 'cifs'])
+      #
+      def create(name:, password:, tag: [])
+        params = { 'name' => name, 'password' => password }
+        params['tag'] = tag unless tag.empty?
+        post('/rci/user', params)
+      end
+
+      # Delete a user.
+      #
+      # @param name [String] User name
+      # @return [Hash, nil] API response
+      #
+      def delete(name:)
+        post('/rci/user', { 'name' => name, 'no' => true })
+      end
+
+      private
+
+      def normalize_users(response)
+        users_data = case response
+                     when Array
+                       response
+                     when Hash
+                       response['user'] || response['users'] || []
+                     else
+                       []
+                     end
+
+        return [] unless users_data.is_a?(Array)
+
+        users_data.map { |user| normalize_user(user) }.compact
+      end
+
+      def normalize_user(data)
+        return nil unless data.is_a?(Hash)
+
+        deep_normalize_keys(data)
+      end
+    end
+  end
+end

data/lib/keenetic/resources/vpn.rb

@@ -0,0 +1,153 @@
+module Keenetic
+  module Resources
+    # VPN resource for managing VPN server and monitoring connections.
+    #
+    # == API Endpoints Used
+    #
+    # === Reading VPN Server Status
+    #   GET /rci/show/vpn-server
+    #   Returns: VPN server configuration and status
+    #
+    # === Reading VPN Clients
+    #   GET /rci/show/vpn-server/clients
+    #   Returns: Array of connected VPN clients
+    #
+    # === Reading IPsec Status
+    #   GET /rci/show/crypto/ipsec/sa
+    #   Returns: IPsec security associations
+    #
+    # === Configuring VPN Server
+    #   POST /rci/vpn-server
+    #   Body: { type, enabled, pool-start, pool-end, ... }
+    #
+    class Vpn < Base
+      # Get VPN server status and configuration.
+      #
+      # == Keenetic API Request
+      #   GET /rci/show/vpn-server
+      #
+      # == Response Fields
+      #   - type: VPN server type (pptp, l2tp, sstp, etc.)
+      #   - enabled: Whether server is enabled
+      #   - running: Whether server is currently running
+      #   - pool_start: Start of IP pool for clients
+      #   - pool_end: End of IP pool for clients
+      #   - interface: VPN interface name
+      #
+      # @return [Hash] VPN server status
+      # @example
+      #   status = client.vpn.status
+      #   # => { type: "l2tp", enabled: true, running: true, ... }
+      #
+      def status
+        response = get('/rci/show/vpn-server')
+        normalize_status(response)
+      end
+
+      # Get connected VPN clients.
+      #
+      # == Keenetic API Request
+      #   GET /rci/show/vpn-server/clients
+      #
+      # == Response Fields (per client)
+      #   - name: Client username
+      #   - ip: Assigned IP address
+      #   - uptime: Connection duration in seconds
+      #   - rxbytes: Bytes received
+      #   - txbytes: Bytes transmitted
+      #
+      # @return [Array<Hash>] List of connected VPN clients
+      # @example
+      #   clients = client.vpn.clients
+      #   # => [{ name: "user1", ip: "192.168.1.200", uptime: 3600, ... }]
+      #
+      def clients
+        response = get('/rci/show/vpn-server/clients')
+        normalize_clients(response)
+      end
+
+      # Get IPsec security associations status.
+      #
+      # == Keenetic API Request
+      #   GET /rci/show/crypto/ipsec/sa
+      #
+      # == Response Fields
+      #   - established: Number of established SAs
+      #   - sa: Array of security associations
+      #
+      # @return [Hash] IPsec status with security associations
+      # @example
+      #   ipsec = client.vpn.ipsec_status
+      #   # => { established: 2, sa: [...] }
+      #
+      def ipsec_status
+        response = get('/rci/show/crypto/ipsec/sa')
+        normalize_ipsec(response)
+      end
+
+      # Configure VPN server.
+      #
+      # == Keenetic API Request
+      #   POST /rci/vpn-server
+      #   Body: { type, enabled, pool-start, pool-end, ... }
+      #
+      # @param type [String] VPN type: "pptp", "l2tp", "sstp"
+      # @param enabled [Boolean] Enable or disable the server
+      # @param pool_start [String, nil] Start of client IP pool
+      # @param pool_end [String, nil] End of client IP pool
+      # @param mppe [String, nil] MPPE encryption: "require", "prefer", "none"
+      # @return [Hash, Array, nil] API response
+      #
+      # @example Enable L2TP server
+      #   client.vpn.configure(
+      #     type: 'l2tp',
+      #     enabled: true,
+      #     pool_start: '192.168.1.200',
+      #     pool_end: '192.168.1.210'
+      #   )
+      #
+      # @example Disable VPN server
+      #   client.vpn.configure(type: 'pptp', enabled: false)
+      #
+      def configure(type:, enabled:, pool_start: nil, pool_end: nil, mppe: nil)
+        params = {
+          'type' => type,
+          'enabled' => enabled
+        }
+        params['pool-start'] = pool_start if pool_start
+        params['pool-end'] = pool_end if pool_end
+        params['mppe'] = mppe if mppe
+
+        post('/rci/vpn-server', params)
+      end
+
+      private
+
+      def normalize_status(response)
+        return {} unless response.is_a?(Hash)
+
+        result = deep_normalize_keys(response)
+        normalize_booleans(result, %i[enabled running])
+        result
+      end
+
+      def normalize_clients(response)
+        return [] unless response.is_a?(Array)
+
+        response.map { |client_data| normalize_client(client_data) }.compact
+      end
+
+      def normalize_client(data)
+        return nil unless data.is_a?(Hash)
+
+        deep_normalize_keys(data)
+      end
+
+      def normalize_ipsec(response)
+        return {} unless response.is_a?(Hash)
+
+        deep_normalize_keys(response)
+      end
+    end
+  end
+end

data/lib/keenetic/version.rb

@@ -1,3 +1,3 @@
 module Keenetic
-  VERSION = '0.2.0'.freeze
+  VERSION = '1.0.0'.freeze
 end

data/lib/keenetic.rb

@@ -16,6 +16,19 @@ require_relative 'keenetic/resources/logs'
 require_relative 'keenetic/resources/routes'
 require_relative 'keenetic/resources/hotspot'
 require_relative 'keenetic/resources/config'
+require_relative 'keenetic/resources/nat'
+require_relative 'keenetic/resources/vpn'
+require_relative 'keenetic/resources/diagnostics'
+require_relative 'keenetic/resources/firewall'
+require_relative 'keenetic/resources/mesh'
+require_relative 'keenetic/resources/usb'
+require_relative 'keenetic/resources/dns'
+require_relative 'keenetic/resources/dyndns'
+require_relative 'keenetic/resources/schedule'
+require_relative 'keenetic/resources/users'
+require_relative 'keenetic/resources/components'
+require_relative 'keenetic/resources/qos'
+require_relative 'keenetic/resources/ipv6'
 
 # Keenetic Router API Client
 #

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: keenetic
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Anton Zaytsev
@@ -52,18 +52,31 @@ files:
 - lib/keenetic/configuration.rb
 - lib/keenetic/errors.rb
 - lib/keenetic/resources/base.rb
+- lib/keenetic/resources/components.rb
 - lib/keenetic/resources/config.rb
 - lib/keenetic/resources/devices.rb
 - lib/keenetic/resources/dhcp.rb
+- lib/keenetic/resources/diagnostics.rb
+- lib/keenetic/resources/dns.rb
+- lib/keenetic/resources/dyndns.rb
+- lib/keenetic/resources/firewall.rb
 - lib/keenetic/resources/hotspot.rb
 - lib/keenetic/resources/internet.rb
+- lib/keenetic/resources/ipv6.rb
 - lib/keenetic/resources/logs.rb
+- lib/keenetic/resources/mesh.rb
+- lib/keenetic/resources/nat.rb
 - lib/keenetic/resources/network.rb
 - lib/keenetic/resources/policies.rb
 - lib/keenetic/resources/ports.rb
+- lib/keenetic/resources/qos.rb
 - lib/keenetic/resources/routes.rb
 - lib/keenetic/resources/routing.rb
+- lib/keenetic/resources/schedule.rb
 - lib/keenetic/resources/system.rb
+- lib/keenetic/resources/usb.rb
+- lib/keenetic/resources/users.rb
+- lib/keenetic/resources/vpn.rb
 - lib/keenetic/resources/wifi.rb
 - lib/keenetic/version.rb
 homepage: https://github.com/antonzaytsev/keenetic-ruby