keenetic 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc71a113a4147e3ffd1035596420469ca8c7d9e9639623fd14172b2137d902f6
-  data.tar.gz: 7fcb0cbd7b8a1219715288354b58bfa7a8f15ed7900334be7fd4014a1de9e788
+  metadata.gz: 55da30f5dcac15dad86d5d93cd6dd35cd8d9f63ee2dfb63f73a8e8b32d66a4bb
+  data.tar.gz: 7be5b4c51ca2b764c7bc2cc68e1bb69402377d3c19106f0e288a15103847bbcd
 SHA512:
-  metadata.gz: e03cfc9b96ac18afa8ec3526d735970e5381983325920aaf0f771c1e31337f4c0800158a320081c696ad973b75eab29846b961ea5ea76d2c12b6209516a894e4
-  data.tar.gz: fba387ac8b75676298f75715b22c1c348d3ca749fe44234b2c0dbd8d01ff6b9554f78ddf19fcea2b4dcfbee17ccadc253f91a5c777c7c91427d89140fab5335e
+  metadata.gz: 655fd847b64bec33b24534d23d8f7459cad8cede50af9e78b5289f615612e334b8bf53e74990569d52e3ee6276ac49e01e83894b35c4fd64c8a8418668fd17da
+  data.tar.gz: 14e3d21ee47872269d4a13bb0794e06d9926eb111e919788122cc76f6d2a6f7cb9af225c39cb9e397883c1194b3e32faa53e7fc58f8619f2bf2314c2052c0f13

data/README.md

@@ -38,9 +38,21 @@ client.network.interfaces       # all interfaces
 client.wifi.access_points       # Wi-Fi networks
 client.internet.status          # internet connectivity
 
+# Static routes
+client.routes.all               # configured static routes
+client.routes.add(network: '10.0.0.0/24', interface: 'Wireguard0', comment: 'VPN')
+
+# DNS-based routes
+client.dns_routes.domain_groups # FQDN domain groups
+client.dns_routes.routes        # DNS-based route mappings
+client.dns_routes.create_domain_group(name: 'domain-list0', description: 'YouTube',
+                                      domains: ['youtube.com', 'googlevideo.com'])
+client.dns_routes.add_route(group: 'domain-list0', interface: 'Wireguard0')
+client.dns_routes.delete_route(index: 'abc123...')
+
 # Port forwarding
 client.nat.rules                # NAT rules
-client.nat.add_forward(index: 1, protocol: 'tcp', port: 8080, 
+client.nat.add_forward(index: 1, protocol: 'tcp', port: 8080,
                        to_host: '192.168.1.100', to_port: 80)
 
 # VPN

data/lib/keenetic/client.rb

@@ -182,6 +182,11 @@ module Keenetic
       @ipv6 ||= Resources::Ipv6.new(self)
     end
 
+    # @return [Resources::DnsRoutes] DNS-based routes and FQDN domain groups resource
+    def dns_routes
+      @dns_routes ||= Resources::DnsRoutes.new(self)
+    end
+
     # Execute arbitrary RCI command(s).
     #
     # Provides raw access to the Keenetic RCI (Remote Command Interface).
@@ -318,6 +323,25 @@ module Keenetic
     def request(method, path, options = {})
       authenticate! unless @authenticated || path == '/auth'
 
+      response = execute_request(method, path, options)
+
+      # Handle 401 by re-authenticating and retrying once
+      if response.code == 401 && path != '/auth'
+        config.logger.debug { "Keenetic: Got 401, re-authenticating..." }
+        @authenticated = false
+        @mutex.synchronize { perform_authentication }
+        
+        response = execute_request(method, path, options)
+        
+        if response.code == 401
+          raise AuthenticationError, "Request unauthorized after re-authentication (HTTP 401)"
+        end
+      end
+
+      handle_response(response)
+    end
+
+    def execute_request(method, path, options)
       url = "#{config.base_url}#{path}"
       
       request_options = {
@@ -342,9 +366,7 @@ module Keenetic
 
       config.logger.debug { "Keenetic: #{method.upcase} #{url}" }
 
-      response = Typhoeus::Request.new(url, request_options).run
-
-      handle_response(response)
+      Typhoeus::Request.new(url, request_options).run
     end
 
     def build_headers
@@ -378,7 +400,7 @@ module Keenetic
       end
     end
 
-    def handle_response(response)
+    def handle_response(response, allow_401: false)
       parse_cookies(response)
 
       if response.timed_out?
@@ -389,7 +411,7 @@ module Keenetic
         raise ConnectionError, "Connection failed: #{response.return_message}"
       end
 
-      unless response.success? || response.code == 401
+      unless response.success? || (allow_401 && response.code == 401)
         if response.code == 404
           raise NotFoundError, "Resource not found"
         end

data/lib/keenetic/resources/dns_routes.rb

@@ -0,0 +1,298 @@
+module Keenetic
+  module Resources
+    # DNS-based routes resource for managing FQDN domain groups and their routing rules.
+    #
+    # DNS-based routing lets you route traffic for a set of domain names through a
+    # specific interface. The router resolves each domain and automatically installs
+    # floating static routes for the resolved IPs.
+    #
+    # Two related concepts are managed here:
+    #
+    # 1. **FQDN Domain Groups** (`object-group fqdn`) — named lists of domains.
+    # 2. **DNS-Proxy Routes** (`dns-proxy route`) — maps a domain group to an interface.
+    #
+    # == API Endpoints Used
+    #
+    # === Reading FQDN Domain Groups
+    #   POST /rci/ (batch)
+    #   Body: [{"show":{"sc":{"object-group":{"fqdn":{}}}}}]
+    #   Returns: Hash keyed by group name
+    #
+    # === Creating FQDN Domain Group
+    #   POST /rci/ (batch)
+    #   Body: [
+    #     webhelp_event,
+    #     {"object-group":{"fqdn":{"<name>":{"description":"...","include":[{"address":"..."}]}}}},
+    #     save_config
+    #   ]
+    #
+    # === Deleting FQDN Domain Group
+    #   POST /rci/ (batch)
+    #   Body: [
+    #     webhelp_event,
+    #     {"object-group":{"fqdn":{"<name>":{"no":true}}}},
+    #     save_config
+    #   ]
+    #
+    # === Reading DNS-Based Routes
+    #   POST /rci/ (batch)
+    #   Body: [{"show":{"sc":{"dns-proxy":{"route":{}}}}}]
+    #   Returns: Array of route entries
+    #
+    # === Creating DNS-Based Route
+    #   POST /rci/ (batch)
+    #   Body: [
+    #     webhelp_event,
+    #     {"dns-proxy":{"route":{"group":"...","interface":"...","comment":"..."}}},
+    #     save_config
+    #   ]
+    #
+    # === Deleting DNS-Based Route
+    #   POST /rci/ (batch)
+    #   Body: [
+    #     webhelp_event,
+    #     {"dns-proxy":{"route":{"no":true,"index":"..."}}},
+    #     save_config
+    #   ]
+    #
+    class DnsRoutes < Base
+      # Get all FQDN domain groups.
+      #
+      # == Keenetic API Request
+      #   POST /rci/ (batch)
+      #   Body: [{"show":{"sc":{"object-group":{"fqdn":{}}}}}]
+      #
+      # == Response Structure from API
+      #   {
+      #     "domain-list0": {
+      #       "description": "youtube.com",
+      #       "include": [{"address": "googlevideo.com"}, {"address": "youtube.com"}]
+      #     }
+      #   }
+      #
+      # @return [Array<Hash>] List of domain groups, each with :name, :description, :domains
+      # @example
+      #   groups = client.dns_routes.domain_groups
+      #   # => [{ name: "domain-list0", description: "youtube.com", domains: ["googlevideo.com", "youtube.com"] }]
+      #
+      def domain_groups
+        response = client.batch([{ 'show' => { 'sc' => { 'object-group' => { 'fqdn' => {} } } } }])
+        fqdn_data = response.dig(0, 'show', 'sc', 'object-group', 'fqdn') || {}
+        normalize_domain_groups(fqdn_data)
+      end
+
+      # Find a single FQDN domain group by name.
+      #
+      # @param name [String] Group name (e.g., "domain-list0")
+      # @return [Hash, nil] Domain group or nil if not found
+      # @example
+      #   group = client.dns_routes.find_domain_group(name: "domain-list0")
+      #   # => { name: "domain-list0", description: "youtube.com", domains: [...] }
+      #
+      def find_domain_group(name:)
+        domain_groups.find { |g| g[:name] == name }
+      end
+
+      # Create an FQDN domain group.
+      #
+      # == Keenetic API Request
+      #   POST /rci/ (batch)
+      #   Body: [webhelp_event, {"object-group":{"fqdn":{"<name>":{"description":"...","include":[...]}}}}, save]
+      #
+      # @param name [String] Group identifier (e.g., "domain-list0")
+      # @param description [String] Human-readable label
+      # @param domains [Array<String>] List of domain names to include
+      # @return [Array<Hash>] API response
+      # @raise [ArgumentError] if name, description, or domains are missing/empty
+      # @example
+      #   client.dns_routes.create_domain_group(
+      #     name: "domain-list0",
+      #     description: "YouTube",
+      #     domains: ["youtube.com", "googlevideo.com"]
+      #   )
+      #
+      def create_domain_group(name:, description:, domains:)
+        raise ArgumentError, 'Name is required' if name.nil? || name.to_s.strip.empty?
+        raise ArgumentError, 'Description is required' if description.nil? || description.to_s.strip.empty?
+        raise ArgumentError, 'Domains cannot be empty' if domains.nil? || domains.empty?
+
+        include_list = domains.map { |d| { 'address' => d.to_s } }
+
+        commands = [
+          webhelp_event,
+          { 'object-group' => { 'fqdn' => { name.to_s => { 'description' => description.to_s, 'include' => include_list } } } },
+          save_config_command
+        ]
+
+        client.batch(commands)
+      end
+
+      # Delete an FQDN domain group.
+      #
+      # == Keenetic API Request
+      #   POST /rci/ (batch)
+      #   Body: [webhelp_event, {"object-group":{"fqdn":{"<name>":{"no":true}}}}, save]
+      #
+      # @param name [String] Group name to delete
+      # @return [Array<Hash>] API response
+      # @raise [ArgumentError] if name is missing
+      # @example
+      #   client.dns_routes.delete_domain_group(name: "domain-list0")
+      #
+      def delete_domain_group(name:)
+        raise ArgumentError, 'Name is required' if name.nil? || name.to_s.strip.empty?
+
+        commands = [
+          webhelp_event,
+          { 'object-group' => { 'fqdn' => { name.to_s => { 'no' => true } } } },
+          save_config_command
+        ]
+
+        client.batch(commands)
+      end
+
+      # Get all DNS-based routes.
+      #
+      # == Keenetic API Request
+      #   POST /rci/ (batch)
+      #   Body: [{"show":{"sc":{"dns-proxy":{"route":{}}}}}]
+      #
+      # == Response Structure from API
+      #   [
+      #     {
+      #       "group": "domain-list0",
+      #       "interface": "Wireguard2",
+      #       "auto": true,
+      #       "index": "c52bba355a2830fdf55ccb3748a879df",
+      #       "comment": ""
+      #     }
+      #   ]
+      #
+      # @return [Array<Hash>] List of DNS-based routes with :group, :interface, :auto, :index, :comment
+      # @example
+      #   routes = client.dns_routes.routes
+      #   # => [{ group: "domain-list0", interface: "Wireguard2", auto: true, index: "c52b...", comment: "" }]
+      #
+      def routes
+        response = client.batch([{ 'show' => { 'sc' => { 'dns-proxy' => { 'route' => {} } } } }])
+        routes_data = response.dig(0, 'show', 'sc', 'dns-proxy', 'route') || []
+        normalize_routes(routes_data)
+      end
+
+      # Find a DNS-based route by FQDN group name.
+      #
+      # @param group [String] FQDN group name
+      # @return [Hash, nil] Route or nil if not found
+      # @example
+      #   route = client.dns_routes.find_route(group: "domain-list0")
+      #   # => { group: "domain-list0", interface: "Wireguard2", index: "...", ... }
+      #
+      def find_route(group:)
+        routes.find { |r| r[:group] == group }
+      end
+
+      # Create a DNS-based route mapping a domain group to an interface.
+      #
+      # == Keenetic API Request
+      #   POST /rci/ (batch)
+      #   Body: [webhelp_event, {"dns-proxy":{"route":{"group":"...","interface":"...","comment":"..."}}}, save]
+      #
+      # @param group [String] FQDN group name (e.g., "domain-list0")
+      # @param interface [String] Target interface (e.g., "Wireguard0")
+      # @param comment [String] Optional description (default: "")
+      # @return [Array<Hash>] API response
+      # @raise [ArgumentError] if group or interface is missing
+      # @example
+      #   client.dns_routes.add_route(group: "domain-list0", interface: "Wireguard0")
+      #
+      def add_route(group:, interface:, comment: '')
+        raise ArgumentError, 'Group is required' if group.nil? || group.to_s.strip.empty?
+        raise ArgumentError, 'Interface is required' if interface.nil? || interface.to_s.strip.empty?
+
+        commands = [
+          webhelp_event,
+          { 'dns-proxy' => { 'route' => { 'group' => group.to_s, 'interface' => interface.to_s, 'comment' => comment.to_s } } },
+          save_config_command
+        ]
+
+        client.batch(commands)
+      end
+
+      # Delete a DNS-based route by its index.
+      #
+      # == Keenetic API Request
+      #   POST /rci/ (batch)
+      #   Body: [webhelp_event, {"dns-proxy":{"route":{"no":true,"index":"..."}}}, save]
+      #
+      # @param index [String] Route index (MD5 hash from routes list)
+      # @return [Array<Hash>] API response
+      # @raise [ArgumentError] if index is missing
+      # @example
+      #   client.dns_routes.delete_route(index: "c52bba355a2830fdf55ccb3748a879df")
+      #
+      def delete_route(index:)
+        raise ArgumentError, 'Index is required' if index.nil? || index.to_s.strip.empty?
+
+        commands = [
+          webhelp_event,
+          { 'dns-proxy' => { 'route' => { 'no' => true, 'index' => index.to_s } } },
+          save_config_command
+        ]
+
+        client.batch(commands)
+      end
+
+      private
+
+      def normalize_domain_groups(fqdn_data)
+        return [] unless fqdn_data.is_a?(Hash)
+
+        fqdn_data.map do |name, data|
+          next nil unless data.is_a?(Hash)
+
+          domains = Array(data['include']).map { |entry| entry['address'] }.compact
+
+          {
+            name: name,
+            description: data['description'],
+            domains: domains
+          }
+        end.compact
+      end
+
+      def normalize_routes(routes_data)
+        return [] unless routes_data.is_a?(Array)
+
+        routes_data.map { |r| normalize_route(r) }.compact
+      end
+
+      def normalize_route(data)
+        return nil unless data.is_a?(Hash)
+
+        {
+          group: data['group'],
+          interface: data['interface'],
+          auto: normalize_boolean(data['auto']),
+          index: data['index'],
+          comment: data['comment']
+        }
+      end
+
+      def webhelp_event
+        {
+          'webhelp' => {
+            'event' => {
+              'push' => {
+                'data' => '{"type":"configuration_change","value":{"url":"/staticRoutes/dns"}}'
+              }
+            }
+          }
+        }
+      end
+
+      def save_config_command
+        { 'system' => { 'configuration' => { 'save' => {} } } }
+      end
+    end
+  end
+end

data/lib/keenetic/version.rb

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

data/lib/keenetic.rb

@@ -29,6 +29,7 @@ require_relative 'keenetic/resources/users'
 require_relative 'keenetic/resources/components'
 require_relative 'keenetic/resources/qos'
 require_relative 'keenetic/resources/ipv6'
+require_relative 'keenetic/resources/dns_routes'
 
 # Keenetic Router API Client
 #

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: keenetic
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Anton Zaytsev
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-02-01 00:00:00.000000000 Z
+date: 2026-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger
@@ -40,7 +39,6 @@ dependencies:
         version: '1.4'
 description: A Ruby client for interacting with Keenetic router REST API. Supports
   authentication, device management, system monitoring, and network interfaces.
-email:
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -58,6 +56,7 @@ files:
 - lib/keenetic/resources/dhcp.rb
 - lib/keenetic/resources/diagnostics.rb
 - lib/keenetic/resources/dns.rb
+- lib/keenetic/resources/dns_routes.rb
 - lib/keenetic/resources/dyndns.rb
 - lib/keenetic/resources/firewall.rb
 - lib/keenetic/resources/hotspot.rb
@@ -84,7 +83,6 @@ licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -99,8 +97,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Ruby client for Keenetic router API
 test_files: []