Work in progress

bin/client.rb

@@ -40,6 +40,10 @@ class PipelineClient
     send_msg("build-analyzer_#{track_slug}", 300)
   end
 
+  def build_test_runner(track_slug)
+    send_msg("build-test-runner_#{track_slug}", 300)
+  end
+
   def release_latest(track_slug)
     send_msg("release-analyzer_#{track_slug}", 30)
   end

bin/invoke.rb

@@ -3,11 +3,22 @@
 require_relative "./client"
 
 pipeline = PipelineClient.new
-r = pipeline.analyze("ruby", "two-fer", "soln-42", "s3://exercism-dev/iterations/fff07700-e1c3-402d-8937-823aeefb159f")
+
+# return
+lang = ARGV[0] || "ruby"
+
+pipeline.build_test_runner(lang)
+exit
+# pipeline.release_latest(lang)
+# exit
+r = pipeline.analyze(lang, "two-fer", "soln-42", "s3://exercism-dev/iterations/fff07700-e1c3-402d-8937-823aeefb159f")
+puts r
+if r["logs"]
   r["logs"].each do |log_line|
     puts "+ #{log_line["cmd"]}"
     puts log_line["stdout"]
     puts log_line["stderr"]
   end
+end
 
 puts r["result"]

bin/router

@@ -9,42 +9,107 @@ front_end_socket = context.socket(ZMQ::ROUTER)
 front_end_socket.bind('tcp://*:5566')
 
 back_end_socket = context.socket(ZMQ::DEALER)
-back_end_socket.bind('tcp://*:5577')
+# back_end_socket = context.socket(ZMQ::ROUTER)
+@back_end_socket = back_end_socket
+
+
+status_socket = context.socket(ZMQ::SUB)
+status_socket.setsockopt(ZMQ::SUBSCRIBE, "")
+status_socket.bind('tcp://*:5555')
 
 poller = ZMQ::Poller.new
 poller.register(back_end_socket, ZMQ::POLLIN)
 poller.register(front_end_socket, ZMQ::POLLIN)
+poller.register(status_socket, ZMQ::POLLIN)
 
-workers = []
+@workers = {}
 
-loop do
-  puts "here"
-  if workers.empty?
+def active_workers
+  active = []
+  cut_off = Time.now.to_i - 2000
+  puts "Cut off #{cut_off}"
+  @workers.each do |k, worker|
+    puts "worker: #{worker}"
+    last_seen = worker[:last_seen]
+    puts "last_seen #{last_seen}"
+    active << worker if last_seen > cut_off
+  end
+  active
 end
 
+def check_active
+  puts "------------------------------"
+  inactive = []
+  cut_off = Time.now.to_i - 15
+  puts "Cut off #{cut_off}"
+  @workers.each do |k, worker|
+    last_seen = worker[:last_seen]
+    puts "last_seen #{last_seen}. #{last_seen} > #{cut_off} .. #{last_seen > cut_off}"
+    worker[:active] = last_seen > cut_off
+    unless worker[:active]
+      inactive << worker
+    end
+    puts "------------------------------"
+    puts worker
+    puts "------------------------------"
+  end
+  inactive.each do |inactive_worker|
+    puts inactive_worker
+    address = inactive_worker[:status]["address"]
+    puts "Unsub #{address}"
+    @back_end_socket.disconnect(address)
+  end
+end
 
+loop do
   poll_result = poller.poll
   break if poll_result == -1
 
-  puts "R: #{poller.readables}"
-  puts "W: #{poller.writables}"
+  puts "POLL #{poll_result}"
 
-  puts ZMQ::POLLIN
-  puts ZMQ::POLLOUT
+  readables = poller.readables
 
-  first_readable = poller.readables.first
-  continue if first_readable.nil?
+  puts "readables #{poller.readables.size}"
+  puts "writables #{poller.writables.size}"
+  puts "workers #{@workers.size}"
 
-  case first_readable
+  continue if readables.empty?
+
+  readables.each do |readable|
+    case readable
+    when status_socket
+      puts "..."
+      msg = ""
+      status_socket.recv_string(msg)
+      status_message = JSON.parse(msg)
+      address = status_message["address"]
+      identity = status_message["identity"]
+      @workers[identity] = { last_seen: Time.now.to_i, status: status_message }
+      back_end_socket.connect(address)
+      puts "STATUS: #{msg}"
+      check_active
     when front_end_socket
+      check_active
+      workers = active_workers
+      if workers.empty?
+        puts "no workers"
         msg = []
         front_end_socket.recv_strings(msg)
-    back_end_socket.send_strings(msg)
+        reply = [msg.first, "", { status: :failed }.to_json]
+        front_end_socket.send_strings(reply)
+      else
+        msg = []
+        front_end_socket.recv_strings(msg)
+        result = back_end_socket.send_strings(msg, 1000)
+        puts result
+      end
     when back_end_socket
       msg = []
       back_end_socket.recv_strings(msg)
+      puts "HERER!!!! #{msg}"
       front_end_socket.send_strings(msg)
     end
   end
+end
 
 # ZMQ::Device.create(front_end_socket, back_end_socket)

bin/test.rb

@@ -0,0 +1,39 @@
+require 'rubygems'
+require 'ffi-rzmq'
+
+context = ZMQ::Context.new 2
+
+req = context.socket(ZMQ::REQ)
+puts req.bind('ipc://routing.ipc')
+
+sleep 2
+
+Thread.new do
+  socket = context.socket(ZMQ::ROUTER)
+  puts socket.setsockopt(ZMQ::IDENTITY, "foobar")
+  puts socket.connect('ipc://routing.ipc')
+
+  sleep 2
+
+  loop do
+    puts "waiting"
+    socket.recv_string(message = '')
+    puts "Received [#{message}]"
+    socket.send_string("OK " + message)
+  end
+
+end
+
+10.times do |request|
+  ss = "Hello #{request}"
+  puts req.setsockopt(ZMQ::IDENTITY, "baz")
+  req.send_string("foobar", ZMQ::SNDMORE)
+  req.send_string("foobar", ZMQ::SNDMORE)
+  req.send_string("foobar", ZMQ::SNDMORE)
+  req.send_string("foobar", ZMQ::SNDMORE)
+  req.send_string("", ZMQ::SNDMORE)
+  req.send_string(ss)
+  puts "Sending string [#{ss}]"
+  req.recv_string(message = '')
+  puts "Received reply #{request}[#{message}]"
+end

lib/pipeline.rb

@@ -37,13 +37,21 @@ module Pipeline
     Pipeline::Build::AnalyzerBuild.(latest_tag, track_slug)
   end
 
+  def self.build_test_runner(track_slug)
+    repo = Pipeline::AnalyzerRepo.test_runner_for_track(track_slug)
+    latest_tag = repo.tags.keys.last
+    if (latest_tag.nil?)
+      latest_tag = "master"
+    end
+    Pipeline::Build::AnalyzerBuild.(latest_tag, track_slug)
+  end
+
   def self.release(language_slug)
-    FileUtils.rm_rf "/tmp/analyzer-env/"
+    puts "Releasing #{language_slug}"
     env_base = "/tmp/analyzer-env/#{SecureRandom.hex}"
     env_base = "/tmp/analyzer-env/1e9c733fd7502974c2a3fdd85da9c844"
     environment = Runtime::RuntimeEnvironment.new(env_base)
     environment.prepare
-    img = Pipeline::Util::ImgWrapper.new
     environment.release_analyzer(language_slug)
   end
 

lib/pipeline/analyzer_repo.rb

@@ -9,6 +9,11 @@ class Pipeline::AnalyzerRepo
     Pipeline::AnalyzerRepo.new(repo_url)
   end
 
+  def self.test_runner_for_track(track_slug)
+    repo_url = "https://github.com/exercism/#{track_slug}-analyzer"
+    Pipeline::AnalyzerRepo.new(repo_url)
+  end
+
   def initialize(repo_url)
     @repo_url = repo_url
     puts repo_dir

lib/pipeline/rpc_server.rb

@@ -1,21 +1,50 @@
 class Pipeline::RpcServer
 
-  attr_reader :context, :socket
+  attr_reader :context, :socket, :identity
 
   def initialize
     @context = ZMQ::Context.new(1)
     @socket = context.socket(ZMQ::REP)
-    socket.connect("tcp://localhost:5577")
+    @identity = SecureRandom.uuid
   end
 
   def listen
+    hostname = Socket.gethostname
+    # socket.setsockopt(ZMQ::IDENTITY, identity)
+    # socket.setsockopt(ZMQ::ROUTING_ID, identity)
+    # socket.connect("tcp://localhost:5577")
+    port = 5555
+    bind_result = -1
+    until bind_result != -1 || port > 5600
+      port += 1
+      # @identity = "#{port}"
+      bind_result = socket.bind("tcp://*:#{port}")
+    end
+    address = "tcp://#{hostname}:#{port}"
+
+    Thread.new do
+      puts "STARTING"
+      emitter = context.socket(ZMQ::PUB)
+      emitter.connect("tcp://localhost:5555")
+      sleep 2
+      loop do
+        emitter.send_string({ msg_type: "status", address: address, identity: identity}.to_json)
+        puts "Sent"
+        sleep 10
+      end
+    end
+
     loop do
       request = ''
       socket.recv_string(request)
       puts "Received request. Data: #{request.inspect}"
       if request.start_with? "build-analyzer_"
-        _, arg = request.split("_")
-        result = Pipeline.build_analyzer(arg)
+        _, track = request.split("_")
+        result = Pipeline.build_analyzer(track)
+        socket.send_string(result.to_json)
+      elsif request.start_with? "build-test-runner_"
+        _, track = request.split("_")
+        result = Pipeline.build_test_runner(track)
         socket.send_string(result.to_json)
       elsif request.start_with? "release-analyzer_"
         _, arg = request.split("_")

lib/pipeline/runtime/runtime_environment.rb

@@ -19,8 +19,9 @@ module Pipeline::Runtime
       current_dir = "#{track_dir}/current"
       FileUtils.mkdir_p release_dir
 
-      img = Pipeline::Util::ImgWrapper.new
-      runc = Pipeline::Util::RuncWrapper.new
+      logs = Pipeline::Util::LogCollector.new
+      img = Pipeline::Util::ImgWrapper.new logs
+      runc = Pipeline::Util::RuncWrapper.new logs
 
       configurator = Pipeline::Util::RuncConfigurator.new
       configurator.seed_from_env
@@ -47,6 +48,7 @@ module Pipeline::Runtime
       system("chmod -R a-w #{release_dir}")
       system("chmod -R go-rwx #{release_dir}")
 
+      puts "current_dir #{current_dir} -> #{release_dir}"
       FileUtils.symlink(release_dir, current_dir, force: true)
     end