uringmachine 0.3 → 0.5

data/lib/uringmachine/dns_resolver.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'resolv'
+
+class UringMachine
+  class DNSResolver
+    def initialize(machine)
+      @machine = machine
+      @requests = UM::Queue.new
+      @nameservers = get_nameservers
+      @fiber = @machine.spin { handle_requests_loop }
+      @last_id = 0
+      @cache = {}
+    end
+
+    def resolve(hostname, type)
+      @machine.push(@requests, [hostname, type, Fiber.current])
+      @machine.yield
+    end
+
+    def handle_requests_loop
+      while true
+        hostname, type, fiber = @machine.shift(@requests)
+        res = do_resolve(hostname, type)
+        @machine.schedule(fiber, res)
+      end
+    end
+
+    def get_nameservers
+      nameservers = []
+      IO.readlines('/etc/resolv.conf').each do |line|
+        if line =~ /^nameserver (.+)$/
+          nameservers << $1.split(/\s+/).first
+        end
+      end
+      nameservers
+    end
+
+    def socket_fd
+      @socket_fd ||= prepare_socket
+    end
+
+    def prepare_socket
+      fd = @machine.socket(UM::AF_INET, UM::SOCK_DGRAM, 0, 0)
+      @machine.bind(fd, '0.0.0.0', 0)
+      @machine.connect(fd, @nameservers.sample, 53)
+      fd
+    end
+
+    def do_resolve(hostname, type, try_count = 0)
+      fd = socket_fd
+      req = prepare_request_packet(hostname, type)
+      msg = req.encode
+      @machine.send(fd, msg, msg.bytesize, 0)
+
+      buf = +''
+      @machine.recv(fd, buf, 16384, 0)
+
+      msg = Resolv::DNS::Message.decode buf
+      addrs = []
+      msg.each_answer do |name, ttl, data|
+        p [name, ttl, data]
+        if data.kind_of?(Resolv::DNS::Resource::IN::A) ||
+          data.kind_of?(Resolv::DNS::Resource::IN::AAAA)
+          addrs << data.address.to_s
+        end
+      end
+      addrs
+    end
+
+    def prepare_request_packet(hostname, type)
+      msg = Resolv::DNS::Message.new
+      msg.id = (@last_id += 1)
+      msg.rd = 1
+      msg.add_question hostname, msg_type(type)
+      msg
+    end
+
+    def msg_type(type)
+      # TODO: add support for other types
+      Resolv::DNS::Resource::IN::A
+    end
+  end
+end

data/lib/uringmachine/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class UringMachine
-  VERSION = '0.3'
+  VERSION = '0.5'
 end

data/lib/uringmachine.rb

@@ -1,5 +1,33 @@
 # frozen_string_literal: true
 
 require_relative './um_ext'
+require_relative 'uringmachine/dns_resolver'
 
 UM = UringMachine
+
+class UringMachine
+  @@fiber_map = {}
+
+  def spin(value = nil, &block)
+    f = Fiber.new do |resume_value|
+      block.(resume_value)
+    rescue Exception => e
+      STDERR.puts "Unhandled fiber exception: #{e.inspect}"
+      STDERR.puts e.backtrace.join("\n")
+      exit
+    ensure
+      @@fiber_map.delete(f)
+      # yield control
+      self.yield
+      p :bad_bad_bad
+    end
+    schedule(f, value)
+    @@fiber_map[f] = true
+    f
+  end
+
+  def resolve(hostname, type = :A)
+    @resolver ||= DNSResolver.new(self)
+    @resolver.resolve(hostname, type)
+  end
+end

data/supressions/ruby.supp

@@ -0,0 +1,71 @@
+{
+  On platforms where memcpy is safe for overlapped memory, the compiler will sometimes replace memmove with memcpy. Valgrind may report a false positive.
+  Memcheck:Overlap
+  fun:__memcpy_chk
+  fun:memmove
+  ...
+}
+{
+  Requiring a file will add it to the loaded features, which may be reported as a leak.
+  Memcheck:Leak
+  ...
+  fun:require_internal
+  ...
+}
+{
+  recursive_list_access creates a hash called `list` that is stored on the threadptr_recursive_hash. This is reported as a memory leak.
+  Memcheck:Leak
+  ...
+  fun:rb_ident_hash_new
+  fun:recursive_list_access
+  fun:exec_recursive
+  ...
+}
+{
+  "Invalid read of size 8" when marking the stack of fibers
+  Memcheck:Addr8
+  fun:each_location*
+  ...
+}
+{
+  Rust probes for statx(buf), will be fixed in Valgrind >= 3.1.6.0
+  Memcheck:Param
+  statx(buf)
+  ...
+  fun:*try_statx*
+  ...
+}
+{
+  Rust probes for statx(file_name), will be fixed in Valgrind >= 3.1.6.0
+  Memcheck:Param
+  statx(file_name)
+  ...
+  fun:*try_statx*
+  ...
+}
+{
+  strscan_do_scan in strscan.c will sometimes replace the ptr of the regex, which can be reported as a memory leak if the regex is stored in an iseq. https://github.com/ruby/ruby/pull/8136
+  Memcheck:Leak
+  ...
+  fun:rb_reg_prepare_re
+  fun:strscan_do_scan
+  ...
+}
+{
+  The callcache table (RCLASS_CC_TBL) is lazily created, so it is allocated when the first method that gets cached. If this happens in a native extension, it may be reported as a memory leak.
+  Memcheck:Leak
+  ...
+  fun:rb_id_table_create
+  ...
+  fun:rb_callable_method_entry
+  ...
+}
+{
+  The date library lazily initializes Regexps using static local variables through the function `regcomp`. The Regexp will end up being reported as a memory leak.
+  Memcheck:Leak
+  ...
+  fun:rb_enc_reg_new
+  ...
+  fun:date__parse
+  ...
+}

data/test/helper.rb

@@ -60,4 +60,12 @@ class UMBaseTest < Minitest::Test
   def teardown
     # @machine&.cleanup
   end
+
+  def assign_port
+    @@port_assign_mutex ||= Mutex.new
+    @@port_assign_mutex.synchronize do
+      @@port ||= 1024 + rand(60000)
+      @@port += 1
+    end
+  end
 end