Gems, workers, networking, oh my!

lib/constants.rb

@@ -1,3 +1,5 @@
 module W3DHubLauncher
   ROOT_PATH = Dir.pwd
+
+  USER_AGENT = "#{NAME} v#{VERSION}".freeze
 end

lib/worker.rb

@@ -1,7 +1,13 @@
 module W3DHubLauncher
   class Worker
+    Response = Data.define(:status, :request_id, :data)
+
     def initialize
       @threads = []
+      @requests = []
+
+      # next available request_id to assign incoming requests
+      @request_id = 0
 
       # listen for requests from frontend
       listener = Thread.new { listen }
@@ -10,15 +16,28 @@ module W3DHubLauncher
       # connect to and monitor Backend web service
       @threads << Thread.new { backend_websocket }
 
-      Ractor.main.send({ message: "3 o'clock 'nd all's well!" })
+      @w3dhub_api = W3DHubLauncher::W3DHubApi.new
 
       listener.join
     end
 
     def listen
       loop do
-        request = Ractor.receive
-        pp request
+        query = Ractor.receive
+        pp query
+
+        case query.type
+        when Request::FETCH_URL
+        when Request::DOWNLOAD_URL
+        when Request::W3DHUB_API_CALL
+          Async do
+            result = @w3dhub_api.send(query.data[:call], *(query.data[:arguments] || []))
+            response = Response.new(result.okay? ? Request::STATUS_COMPLETE : Request::STATUS_ERROR, query.request_id, result)
+            Ractor.main.send(response)
+          end
+        else
+          raise "UNKNOWN REQUEST"
+        end
       end
     end
 

lib/worker/request.rb

@@ -0,0 +1,64 @@
+module W3DHubLauncher
+  class Worker
+    class Request
+      Query = Data.define(:type, :request_id, :data)
+
+      FETCH_URL = 0
+      DOWNLOAD_URL = 1
+      W3DHUB_API_CALL = 10
+
+      STATUS_ERROR = -1 # request has failed
+      STATUS_PENDING = 0 # request has not yet started
+      STATUS_OK = 1 # request completed successfully
+      STATUS_COMPLETE = STATUS_OK
+      STATUS_IN_PROGRESS = 2 # request is in progress
+      STATUS_BUSY = STATUS_IN_PROGRESS
+
+      # NOT "Thread"/Ractor safe
+      @request_id = 0
+      @requests = []
+
+      # NOT "Thread"/Ractor safe. Only call from main ractor
+      # returns next available request id, and auto increments by 1
+      def self.request_id
+        @request_id += 1
+      end
+
+      # NOT "Thread"/Ractor safe.
+      # returns an array of pending requests
+      def self.requests
+        @requests
+      end
+
+      attr_reader :type, :data, :request_id
+
+      def initialize(type, data, request_id: Request.request_id, &block)
+        @type = type.freeze
+        @data = data.freeze
+        @status = STATUS_PENDING
+
+        @request_id = request_id
+        @callback = block # only called on error or success
+
+        enqueue(@type, @request_id, @data)
+      end
+
+      def enqueue(type, id, data)
+        Request.requests << self
+        W3DHubLauncher::WORKER.send(Query.new(type, id, data))
+      end
+
+      # event from Worker received
+      def handle_event(event, data)
+        pp [event, data]
+
+        case event
+        when STATUS_COMPLETE
+          Request.requests.delete(self)
+        when STATUS_ERROR
+          Request.requests.delete(self)
+        end
+      end
+    end
+  end
+end

lib/worker/w3dhub_api.rb

@@ -0,0 +1,109 @@
+module W3DHubLauncher
+  class W3DHubApi
+    API_TIMEOUT = 30 # seconds
+    API_CONNECT_TIMEOUT = 10 # seconds
+
+    PRIMARY_W3DHUB_API_ENDPOINT = "https://secure.w3dhub.com".freeze
+    ALTERNATIVE_W3DHUB_API_ENDPOINT = "https://backend.w3d.cyberarm.dev".freeze
+
+    def initialize
+      @access_token = nil
+    end
+
+    def headers(form_encoded: false)
+    end
+
+    # return raw response to requester
+    def fetch(url, method: :get, body: nil, headers: headers())
+      result = CyberarmEngine::Result.new
+
+      Sync do |task|
+        task.with_timeout(API_TIMEOUT) do
+          Async::HTTP::Internet.send(method, url, headers, body) do |response|
+            result.data = response.read
+          rescue StandardError => e
+            result.error = e
+          end
+        rescue Async::TimeoutError
+          result.error = e
+        end
+      end
+
+      result
+    end
+
+    # write response to file, periodically reporting progress to requester
+    def download(url, path:, method: :get, body: nil, headers: headers(), &block)
+      result = CyberarmEngine::Result.new
+
+      Sync do |task|
+        task.with_timeout(API_TIMEOUT) do
+          Async::HTTP::Internet.send(method, url, headers, body) do |response|
+            if response.success?
+              content_length = response.headers["content-length"] || 0
+
+              total_downloaded_bytes = 0
+              File.open(path, "wb") do |file|
+                response.each do |chunk|
+                  file.write(chunk)
+                  downloaded_bytes = chunk.length
+                  total_downloaded_bytes += downloaded_bytes
+
+                  block&.call(downloaded_bytes, total_downloaded_bytes, content_length)
+                end
+              end
+
+              result.data = true
+            end
+          rescue StandardError => e
+            result.error = e
+          end
+        rescue Async::TimeoutError
+          result.error = e
+        end
+      end
+
+      result
+    end
+
+    def user_login()
+      result = CyberarmEngine::Result.new
+    end
+
+    def refresh_user_login()
+      result = CyberarmEngine::Result.new
+    end
+
+    def fetch_user_details()
+      result = CyberarmEngine::Result.new
+    end
+
+    def fetch_applications
+      result = CyberarmEngine::Result.new
+    end
+
+    def fetch_news()
+      result = CyberarmEngine::Result.new
+    end
+
+    def fetch_events()
+      result = CyberarmEngine::Result.new
+    end
+
+    def fetch_manifest()
+      result = CyberarmEngine::Result.new
+    end
+
+    def fetch_manifests()
+      result = CyberarmEngine::Result.new
+    end
+
+    def fetch_package_details()
+      result = CyberarmEngine::Result.new
+    end
+
+    def fetch_package()
+      download()
+    end
+  end
+end