antd 0.1.0

data/lib/antd/discover.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module Antd
+  # Auto-discovers the antd daemon by reading the +daemon.port+ file that antd
+  # writes on startup.
+  #
+  # The file contains up to three lines: REST port (line 1), gRPC port (line 2),
+  # and optionally the daemon PID (line 3).
+  #
+  # If a PID is present and the process is no longer alive, the port file is
+  # considered stale and discovery returns empty.
+  #
+  # Port file location is platform-specific:
+  #   - Windows: %APPDATA%\ant\sdk\daemon.port
+  #   - macOS:   ~/Library/Application Support/ant/sdk/daemon.port
+  #   - Linux:   $XDG_DATA_HOME/ant/sdk/daemon.port or ~/.local/share/ant/sdk/daemon.port
+  #
+  # The +sdk+ subdirectory keeps antd's port file separate from the ant-node
+  # daemon, which writes to the same +ant+ umbrella dir.
+  module Discover
+    PORT_FILE_NAME  = "daemon.port"
+    DATA_DIR_NAME   = "ant"
+    SDK_SUBDIR_NAME = "sdk"
+
+    # Reads the daemon.port file and returns the REST base URL
+    # (e.g. "http://127.0.0.1:8082").
+    #
+    # @return [String] the URL, or "" if the port file is not found
+    def self.daemon_url
+      rest, _ = read_port_file
+      return "" if rest == 0
+
+      "http://127.0.0.1:#{rest}"
+    end
+
+    # Reads the daemon.port file and returns the gRPC target
+    # (e.g. "127.0.0.1:50051").
+    #
+    # @return [String] the target, or "" if the port file is not found
+    def self.grpc_target
+      _, grpc = read_port_file
+      return "" if grpc == 0
+
+      "127.0.0.1:#{grpc}"
+    end
+
+    # @api private
+    def self.read_port_file
+      dir = data_dir
+      return [0, 0] if dir.empty?
+
+      path = File.join(dir, PORT_FILE_NAME)
+      return [0, 0] unless File.exist?(path)
+
+      lines = File.read(path).strip.split("\n")
+      rest_port = parse_port(lines[0])
+      grpc_port = parse_port(lines[1])
+      pid = parse_pid(lines[2])
+
+      return [0, 0] if pid > 0 && !process_alive?(pid)
+
+      [rest_port, grpc_port]
+    rescue StandardError
+      [0, 0]
+    end
+
+    # @api private
+    def self.parse_port(str)
+      return 0 if str.nil?
+
+      s = str.strip
+      return 0 unless s.match?(/\A\d+\z/)
+
+      n = s.to_i
+      (n > 0 && n <= 65535) ? n : 0
+    end
+
+    # @api private
+    def self.data_dir
+      host_os = RbConfig::CONFIG["host_os"]
+
+      case host_os
+      when /mswin|mingw|cygwin/
+        appdata = ENV["APPDATA"]
+        return "" if appdata.nil? || appdata.empty?
+
+        File.join(appdata, DATA_DIR_NAME, SDK_SUBDIR_NAME)
+      when /darwin/
+        home = ENV["HOME"]
+        return "" if home.nil? || home.empty?
+
+        File.join(home, "Library", "Application Support", DATA_DIR_NAME, SDK_SUBDIR_NAME)
+      else
+        xdg = ENV["XDG_DATA_HOME"]
+        if xdg && !xdg.empty?
+          File.join(xdg, DATA_DIR_NAME, SDK_SUBDIR_NAME)
+        else
+          home = ENV["HOME"]
+          return "" if home.nil? || home.empty?
+
+          File.join(home, ".local", "share", DATA_DIR_NAME, SDK_SUBDIR_NAME)
+        end
+      end
+    end
+
+    # @api private
+    def self.parse_pid(str)
+      return 0 if str.nil?
+
+      s = str.strip
+      return 0 unless s.match?(/\A\d+\z/)
+
+      n = s.to_i
+      n > 0 ? n : 0
+    end
+
+    # @api private
+    def self.process_alive?(pid)
+      Process.kill(0, pid)
+      true
+    rescue Errno::ESRCH
+      false
+    rescue Errno::EPERM
+      # Process exists but we lack permission to signal it — still alive.
+      true
+    end
+
+    private_class_method :read_port_file, :parse_port, :parse_pid, :process_alive?, :data_dir
+  end
+end

data/lib/antd/errors.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Antd
+  # Base error type for all antd errors.
+  class AntdError < StandardError
+    attr_reader :status_code
+
+    def initialize(message, status_code:)
+      @status_code = status_code
+      super("antd error #{status_code}: #{message}")
+    end
+  end
+
+  # Invalid request parameters (HTTP 400).
+  class BadRequestError < AntdError
+    def initialize(message) = super(message, status_code: 400)
+  end
+
+  # Insufficient funds or payment failure (HTTP 402).
+  class PaymentError < AntdError
+    def initialize(message) = super(message, status_code: 402)
+  end
+
+  # Resource not found on the network (HTTP 404).
+  class NotFoundError < AntdError
+    def initialize(message) = super(message, status_code: 404)
+  end
+
+  # Resource already exists (HTTP 409).
+  class AlreadyExistsError < AntdError
+    def initialize(message) = super(message, status_code: 409)
+  end
+
+  # Version conflict or fork detected (HTTP 409).
+  class ForkError < AntdError
+    def initialize(message) = super(message, status_code: 409)
+  end
+
+  # Payload too large (HTTP 413).
+  class TooLargeError < AntdError
+    def initialize(message) = super(message, status_code: 413)
+  end
+
+  # Internal server error (HTTP 500).
+  class InternalError < AntdError
+    def initialize(message) = super(message, status_code: 500)
+  end
+
+  # Daemon cannot reach the network (HTTP 502).
+  class NetworkError < AntdError
+    def initialize(message) = super(message, status_code: 502)
+  end
+
+  # Service unavailable, e.g. wallet not configured (HTTP 503).
+  class ServiceUnavailableError < AntdError
+    def initialize(message) = super(message, status_code: 503)
+  end
+
+  # Returns the appropriate error type for an HTTP status code.
+  def self.error_for_status(code, message)
+    case code
+    when 400 then BadRequestError.new(message)
+    when 402 then PaymentError.new(message)
+    when 404 then NotFoundError.new(message)
+    when 409 then AlreadyExistsError.new(message)
+    when 413 then TooLargeError.new(message)
+    when 500 then InternalError.new(message)
+    when 502 then NetworkError.new(message)
+    when 503 then ServiceUnavailableError.new(message)
+    else          AntdError.new(message, status_code: code)
+    end
+  end
+end