cosmos 4.5.1 → 5.0.2

data/lib/cosmos/io/json_api_object.rb

@@ -0,0 +1,210 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# This program may also be used under the terms of a commercial or
+# enterprise edition license of COSMOS if purchased from the
+# copyright holder
+
+require 'cosmos'
+require 'cosmos/utilities/authentication'
+require 'cosmos/io/json_drb'
+
+require 'thread'
+require 'socket'
+require 'json'
+# require 'drb/acl'
+require 'drb/drb'
+require 'uri'
+require 'httpclient'
+
+
+module Cosmos
+
+  class JsonApiError < StandardError; end
+
+  # Used to forward all method calls to the remote server object. Before using
+  # this class ensure the remote service has been started in the server class:
+  #
+  #   json = JsonDrb.new
+  #   json.start_service('127.0.0.1', 7777, self)
+  #
+  # Now the JsonApiObject can be used to call server methods directly:
+  #
+  #   server = JsonApiObject('http://cosmos-cmd-tlm-api:2901', 1.0)
+  #   server.cmd(*args)
+  #
+  class JsonApiObject 
+    attr_reader :request_data
+    attr_reader :response_data
+
+    USER_AGENT = 'Cosmos / v5 (ruby/cosmos/lib/io/json_api_object)'.freeze
+
+    # @param url [String] The url of cosmos-cmd-tlm-api http://cosmos-cmd-tlm-api:2901
+    # @param timeout [Float] The time to wait before disconnecting 1.0
+    # @param authentication [CosmosAuthentication] The authentication object if nill initialize will generate
+    def initialize(url: ENV['COSMOS_API_URL'], timeout: 1.0, authentication: nil)
+      @http = nil
+      @mutex = Mutex.new
+      @request_data = ""
+      @response_data = ""
+      @url = url
+      @log = [nil, nil, nil]
+      @authentication = authentication.nil? ? CosmosAuthentication.new() : authentication
+      @timeout = timeout
+      @shutdown = false
+    end
+
+    # Forwards all method calls to the remote service.
+    #
+    # @param method_params [Array] Array of parameters to pass to the method
+    # @param keyword_params [Hash<Symbol, Variable>] Hash of keyword parameters
+    # @return The result of the method call. 
+    def request(*method_params, **keyword_params)
+      raise JsonApiError, "Shutdown" if @shutdown
+      method = method_params[0]
+      endpoint = method_params[1]
+      @mutex.synchronize do
+        kwargs = _generate_kwargs(keyword_params)
+        for attempt in 1..3
+          @log = [nil, nil, nil]
+          connect() if !@http
+          response = _send_request(method: method, endpoint: endpoint, kwargs: kwargs)
+          return response unless response.code >= 500
+          sleep attempt
+        end
+        return nil
+      end
+    end
+
+    # Disconnects from http server
+    def disconnect
+      @http.reset_all() if @http
+      @http = nil
+    end
+
+    # Permanently disconnects from the http server
+    def shutdown
+      @shutdown = true
+      disconnect()
+    end
+
+    private
+
+    def connect
+      begin
+        @http = HTTPClient.new
+        @http.connect_timeout = @timeout
+        @http.receive_timeout = nil # Allow long polling
+      rescue => e
+        raise JsonApiError, e.message
+      end
+    end
+
+    # NOTE: This is a helper method and should not be called directly
+    def _generate_kwargs(keyword_params)
+      kwargs = {}
+      keyword_params.each do |key, value|
+        kwargs[key.intern] = value
+      end
+      kwargs[:scope] = _generate_scope(kwargs)
+      kwargs[:headers] = _generate_headers(kwargs)
+      kwargs[:data] = _generate_data(kwargs)
+      kwargs[:query] = _generate_query(kwargs)
+      return kwargs
+    end
+
+    # NOTE: This is a helper method and should not be called directly
+    def _generate_scope(kwargs)
+      scope = kwargs[:scope]
+      if scope.nil?
+        raise JsonApiError, "no scope keyword found: #{kwargs}"
+      elsif scope.is_a?(String) == false
+        raise JsonApiError, "incorrect type for keyword 'scope' MUST be String: #{scope}"
+      end
+      return scope
+    end
+
+    # NOTE: This is a helper method and should not be called directly
+    def _generate_headers(kwargs)
+      headers = kwargs[:headers]
+      if headers.nil?
+        headers = kwargs[:headers] = {}
+      elsif headers.is_a?(Hash) == false
+        raise JsonApiError, "incorrect type for keyword 'headers' MUST be Hash: #{headers}"
+      end
+      
+      headers['Content-Type'] = 'application/json' if kwargs[:json]
+      return headers.update({
+        'User-Agent' => USER_AGENT,
+        'Authorization' => @authentication.token(),
+      })
+    end
+
+    # NOTE: This is a helper method and should not be called directly
+    def _generate_data(kwargs)
+      data = kwargs[:data]
+      if data.nil?
+        data = kwargs[:data] = {}
+      elsif data.is_a?(Hash) == false
+        raise JsonApiError, "incorrect type for keyword 'data' MUST be Hash: #{data}"
+      end
+      return kwargs[:json] ? JSON.generate(kwargs[:data]) : kwargs[:data]
+    end
+
+    # NOTE: This is a helper method and should not be called directly
+    def _generate_query(kwargs)
+      query = kwargs[:query]
+      if query.nil?
+        query = kwargs[:query] = {}
+      elsif query.is_a?(Hash) == false
+        raise JsonApiError, "incorrect type for keyword 'query' MUST be Hash: #{query}"
+      end
+      kwargs[:query].update(:scope => kwargs[:scope]) if kwargs[:scope]
+    end
+
+    # NOTE: This is a helper method and should not be called directly
+    def _send_request(method:, endpoint:, kwargs:)
+      begin
+        uri = URI("#{@url}#{endpoint}")
+        @log[0] = "#{method} Request: #{uri.to_s} #{kwargs}"
+        STDOUT.puts @log[0] if JsonDRb.debug?
+        resp = _http_request(method: method, uri: uri, kwargs: kwargs)
+        @log[1] = "#{method} Response: #{resp.status} #{resp.headers} #{resp.body}"
+        STDOUT.puts @log[1] if JsonDRb.debug?
+        @response_data = resp.body
+        return resp
+      rescue StandardError => e
+        @log[2] = "#{method} Exception: #{e.class}, #{e.message}, #{e.backtrace}"
+      end
+    end
+
+    # NOTE: This is a helper method and should not be called directly
+    def _http_request(method:, uri:, kwargs:)
+      case method
+      when 'get', :get
+        return @http.get(uri, :header => kwargs[:headers], :query => kwargs[:query])
+      when 'post', :post
+        return @http.post(uri, :header => kwargs[:headers], :query => kwargs[:query], :body => kwargs[:data])
+      when 'put', :put
+        return @http.put(uri, :header => kwargs[:headers], :query => kwargs[:query], :body => kwargs[:data])
+      when 'delete', :delete
+        return @http.delete(uri, :header => kwargs[:headers], :query => kwargs[:query])
+      else
+        raise JsonApiError, "no method found: '#{method}'"
+      end
+    end
+
+  end # class JsonApiObject
+end # module Cosmos

data/lib/cosmos/io/json_drb.rb

@@ -1,30 +1,31 @@
 # encoding: ascii-8bit
 
-# Copyright 2014 Ball Aerospace & Technologies Corp.
+# Copyright 2022 Ball Aerospace & Technologies Corp.
 # All Rights Reserved.
 #
 # This program is free software; you can modify and/or redistribute it
-# under the terms of the GNU Lesser General Public License
+# under the terms of the GNU Affero General Public License
 # as published by the Free Software Foundation; version 3 with
 # attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# This program may also be used under the terms of a commercial or
+# enterprise edition license of COSMOS if purchased from the
+# copyright holder
 
 require 'thread'
 require 'socket'
 require 'json'
-require 'drb/acl'
+# require 'drb/acl'
 require 'drb/drb'
 require 'set'
 require 'cosmos/io/json_rpc'
 require 'cosmos/io/json_drb_rack'
 require 'rack/handler/puma'
-if RUBY_ENGINE == 'ruby' and %w(2.2.7 2.2.8 2.2.9 2.2.10 2.3.4 2.4.1).include? RUBY_VERSION
-  begin
-    require 'stopgap_13632'
-  rescue Exception => err
-    msg = "Error loading stopgap. Make sure gem install stopgap_13632 succeeds: #{err.message}"
-    raise $!, msg, $!.backtrace
-  end
-end
 
 # Add methods to the Puma::Launcher and Puma::Single class so we can tell
 # if the server has been started.
@@ -34,8 +35,10 @@ module Puma
       @runner and @runner.running
     end
   end
+
   class Runner
   end
+
   class Single < Runner
     def running
       @server and @server.running
@@ -65,11 +68,13 @@ module Cosmos
     # @return [Array<String>] List of methods that should be allowed
     attr_accessor :method_whitelist
     # @return [ACL] The access control list
-    attr_accessor :acl
+    # attr_accessor :acl
+
+    attr_accessor :object
 
     def initialize
       @thread = nil
-      @acl = nil
+      # @acl = nil
       @object = nil
       @method_whitelist = nil
       @request_count = 0
@@ -111,19 +116,15 @@ module Cosmos
     # Gracefully kill the thread
     def graceful_kill
       @server_mutex.synchronize do
-        begin
-          @server.stop if @server and @server.running
-        rescue
-        end
+        @server.stop if @server and @server.running
+      rescue
       end
     end
 
     # @param hostname [String] The host to start the service on
     # @param port [Integer] The port number to listen for connections
-    # @param object [Object] The object to send the DRb requests to. This
-    #   object must either include the Cosmos::Script module or be the
-    #   CmdTlmServer.
-    def start_service(hostname = nil, port = nil, object = nil, max_threads = 1000, system = nil)
+    # @param object [Object] The object to send the DRb requests to.
+    def start_service(hostname = nil, port = nil, object = nil, max_threads = 1000)
       server_started = false
       @server_mutex.synchronize do
         server_started = true if @server
@@ -132,59 +133,58 @@ module Cosmos
 
       if hostname and port and object
         @object = object
-        hostname = '127.0.0.1'.freeze if (hostname.to_s.upcase == 'LOCALHOST'.freeze)
+        hostname = '127.0.0.1'.freeze if hostname.to_s.upcase == 'LOCALHOST'.freeze
 
         @thread = Thread.new do
-
           # Create an http server to accept requests from clients
-          begin
-            server_config = {
-              :Host   => hostname,
-              :Port   => port,
-              :Silent => true,
-              :Verbose => false,
-              :Threads => "0:#{max_threads}",
-            }
-
-            # The run call will block until the server is stopped.
-            Rack::Handler::Puma.run(JsonDrbRack.new(self, system), server_config) do |server|
-              @server_mutex.synchronize do
-                @server = server
-              end
-            end
 
-            # Wait for all puma threads to stop before trying to close
-            # the sockets
-            start_time = Time.now
-            while true
-              puma_threads = false
-              Thread.list.each {|thread| puma_threads = true if thread.inspect.match(/puma/)}
-              break if !puma_threads
-              break if (Time.now - start_time) > PUMA_THREAD_TIMEOUT
-              sleep 0.25
-            end
+          server_config = {
+            :Host => hostname,
+            :Port => port,
+            :Silent => true,
+            :Verbose => false,
+            :Threads => "0:#{max_threads}",
+          }
 
-            # Puma doesn't clean up it's own sockets after shutting down,
-            # so we'll do that here.
+          # The run call will block until the server is stopped.
+          Rack::Handler::Puma.run(JsonDrbRack.new(self), server_config) do |server|
             @server_mutex.synchronize do
-              @server.binder.close() if @server
+              @server = server
             end
+          end
+
+          # Wait for all puma threads to stop before trying to close
+          # the sockets
+          start_time = Time.now
+          while true
+            puma_threads = false
+            Thread.list.each { |thread| puma_threads = true if thread.inspect.match?(/puma/) }
+            break if !puma_threads
+            break if (Time.now - start_time) > PUMA_THREAD_TIMEOUT
 
-          # The address in use error is pretty typical if an existing
-          # CmdTlmServer is running so explicitly rescue this
-          rescue Errno::EADDRINUSE
-            @server = nil
-            raise "Error binding to port #{port}.\n" +
-                  "Either another application is using this port\n" +
-                  "or the operating system is being slow cleaning up.\n" +
-                  "Make sure all sockets/streams are closed in all applications,\n" +
-                  "wait 1 minute and try again."
-          # Something else went wrong which is fatal
-          rescue => error
-            @server = nil
-            Logger.error "JsonDRb http server could not be started or unexpectedly died.\n#{error.formatted}"
-            Cosmos.handle_fatal_exception(error)
+            sleep 0.25
+          end
+
+          # Puma doesn't clean up it's own sockets after shutting down,
+          # so we'll do that here.
+          @server_mutex.synchronize do
+            @server.binder.close() if @server
           end
+
+        # The address in use error is pretty typical if an existing
+        # server is running so explicitly rescue this
+        rescue Errno::EADDRINUSE
+          @server = nil
+          raise "Error binding to port #{port}.\n" +
+                "Either another application is using this port\n" +
+                "or the operating system is being slow cleaning up.\n" +
+                "Make sure all sockets/streams are closed in all applications,\n" +
+                "wait 1 minute and try again."
+        # Something else went wrong which is fatal
+        rescue => error
+          @server = nil
+          Logger.error "JsonDRb http server could not be started or unexpectedly died.\n#{error.formatted}"
+          Cosmos.handle_fatal_exception(error)
         end
 
         # Wait for the server to be started in the thread before returning.
@@ -205,9 +205,7 @@ module Cosmos
     end
 
     # @return [Thread] The server thread listening for incoming requests
-    def thread
-      @thread
-    end
+    attr_reader :thread
 
     # Adds a request time to the list. A request time consists of the amount of
     # time to receive the request, process it, and send the response. These
@@ -247,14 +245,14 @@ module Cosmos
     # Process the JSON request data, execute the method, and create a response.
     #
     # @param request_data [String] The JSON encoded request
+    # @param request_headers [Hash] The requests headers sent with the request
     # @param start_time [Time] The time when the initial request was received
     # @return response_data, error_code [String, Integer/nil] The JSON encoded
     #   response and error code
-    def process_request(request_data, start_time)
+    def process_request(request_data:, request_headers:, start_time:)
       @request_count += 1
-      STDOUT.puts request_data if JsonDRb.debug?
       begin
-        request = JsonRpcRequest.from_json(request_data)
+        request = JsonRpcRequest.from_json(request_data, request_headers)
         response = nil
         error_code = nil
         response_data = nil
@@ -262,24 +260,42 @@ module Cosmos
         if (@method_whitelist and @method_whitelist.include?(request.method.downcase())) or
            (!@method_whitelist and !JsonRpcRequest::DANGEROUS_METHODS.include?(request.method.downcase()))
           begin
-            result = @object.public_send(request.method.downcase().intern, *request.params)
+            if request.keyword_params
+              result = @object.public_send(request.method.downcase().intern, *request.params, **request.keyword_params)
+            else
+              result = @object.public_send(request.method.downcase().intern, *request.params)
+            end
             if request.id
               response = JsonRpcSuccessResponse.new(result, request.id)
             end
           rescue Exception => error
+            Logger.error error.formatted
             if request.id
               if NoMethodError === error
                 error_code = JsonRpcError::ErrorCode::METHOD_NOT_FOUND
                 response = JsonRpcErrorResponse.new(
-                  JsonRpcError.new(error_code, "Method not found", error), request.id)
+                  JsonRpcError.new(error_code, "Method not found", error), request.id
+                )
               elsif ArgumentError === error
                 error_code = JsonRpcError::ErrorCode::INVALID_PARAMS
                 response = JsonRpcErrorResponse.new(
-                  JsonRpcError.new(error_code, "Invalid params", error), request.id)
+                  JsonRpcError.new(error_code, "Invalid params", error), request.id
+                )
+              elsif AuthError === error
+                error_code = JsonRpcError::ErrorCode::AUTH_ERROR
+                response = JsonRpcErrorResponse.new(
+                  JsonRpcError.new(error_code, error.message, error), request.id
+                )
+              elsif ForbiddenError === error
+                error_code = JsonRpcError::ErrorCode::FORBIDDEN_ERROR
+                response = JsonRpcErrorResponse.new(
+                  JsonRpcError.new(error_code, error.message, error), request.id
+                )
               else
                 error_code = JsonRpcError::ErrorCode::OTHER_ERROR
                 response = JsonRpcErrorResponse.new(
-                  JsonRpcError.new(error_code, error.message, error), request.id)
+                  JsonRpcError.new(error_code, error.message, error), request.id
+                )
               end
             end
           end
@@ -287,7 +303,8 @@ module Cosmos
           if request.id
             error_code = JsonRpcError::ErrorCode::OTHER_ERROR
             response = JsonRpcErrorResponse.new(
-              JsonRpcError.new(error_code, "Cannot call unauthorized methods"), request.id)
+              JsonRpcError.new(error_code, "Cannot call unauthorized methods"), request.id
+            )
           end
         end
         response_data = process_response(response, start_time) if response
@@ -310,6 +327,5 @@ module Cosmos
       add_request_time(request_time)
       return response_data
     end
-
   end
 end