cosmos 4.5.2 → 5.0.2.pre.beta2

data/lib/cosmos/io/json_drb_object.rb

@@ -1,25 +1,29 @@
 # 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 'cosmos'
-require 'thread'
-require 'socket'
-require 'json'
-require 'drb/acl'
-require 'drb/drb'
-require 'cosmos/io/json_drb'
-require 'uri'
-require 'httpclient'
+require 'cosmos/io/json_api_object'
 
 module Cosmos
 
+  class JsonDRbError < JsonApiError; 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:
   #
@@ -28,145 +32,84 @@ module Cosmos
   #
   # Now the JsonDRbObject can be used to call server methods directly:
   #
-  #   server = JsonDRbObject('127.0.0.1', 7777)
+  #   server = JsonDRbObject('http://cosmos-cmd-tlm-api:2901', 1.0)
   #   server.cmd(*args)
   #
-  class JsonDRbObject
-    attr_reader :request_data
-    attr_reader :response_data
+  class JsonDRbObject < JsonApiObject
 
-    # @param hostname [String] The name of the machine which has started
-    #   the JSON service
-    # @param port [Integer] The port number of the JSON service
-    def initialize(hostname, port, connect_timeout = 1.0, x_csrf_token = nil)
-      hostname = '127.0.0.1' if (hostname.to_s.upcase == 'LOCALHOST')
-      begin
-        Socket.pack_sockaddr_in(port, hostname)
-      rescue => error
-        if error.message =~ /getaddrinfo/
-          raise "Invalid hostname: #{hostname}"
-        else
-          raise error
-        end
-      end
-      @request_data = ""
-      @response_data = ""
-      @hostname = hostname
-      @port = port
-      @uri = URI("http://#{@hostname}:#{@port}")
-      @http = nil
-      @mutex = Mutex.new
-      @id = 0
-      @request_in_progress = false
-      @connect_timeout = connect_timeout
-      @connect_timeout = @connect_timeout.to_f if @connect_timeout
-      @shutdown = false
-      @x_csrf_token = x_csrf_token
-    end
-
-    # Disconnects from http server
-    def disconnect
-      @http.reset_all if @http
-    end
+    USER_AGENT = 'Cosmos / v5 (ruby/cosmos/lib/io/json_drb_object)'
 
-    # Permanently disconnects from the http server
-    def shutdown
-      @shutdown = true
-      disconnect()
+    # @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)
+      super(url: url, timeout: timeout, authentication: authentication)
+      @uri = URI("#{url}/cosmos-api/api")
     end
 
     # Forwards all method calls to the remote service.
     #
     # @param method_name [Symbol] Name of the method to call
     # @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. If the method raises an exception
     #   the same exception is also raised. If something goes wrong with the
-    #   protocol a DRb::DRbConnError exception is raised.
-    def method_missing(method_name, *method_params)
+    #   protocol a JsonDRbError exception is raised.
+    def method_missing(method_name, *method_params, **keyword_params)
+      raise JsonDRbError, "Shutdown" if @shutdown
       @mutex.synchronize do
-        first_try = true
-        loop do
-          raise DRb::DRbConnError, "Shutdown" if @shutdown
-          connect() if !@http or @request_in_progress
-
-          response = make_request(method_name, method_params, first_try)
-          unless response
+        for attempt in 1..3
+          @log = [nil, nil, nil]
+          connect() if !@http
+          json_rpc_request = JsonRpcRequest.new(method_name, method_params, keyword_params, @id)
+          data = json_rpc_request.to_json(:allow_nan => true)
+          response_body = make_request(data: data)
+          if !response_body or response_body.to_s.length < 1
             disconnect()
-            was_first_try = first_try
-            first_try = false
-            next if was_first_try
+          else
+            response = JsonRpcResponse.from_json(response_body)
+            return handle_response(response: response)
           end
-          return handle_response(response)
         end
+        error = "#{attempt} no response from server: #{@log[0]} ::: #{@log[1]} ::: #{@log[2]}"
+        raise JsonDRbError, error
       end
     end
 
     private
 
-    def connect
-      if @request_in_progress
-        disconnect()
-        @request_in_progress = false
-      end
-      begin
-        if !@http
-          @http = HTTPClient.new
-          @http.connect_timeout = @connect_timeout
-          @http.receive_timeout = nil # Allow long polling
-        end
-      rescue => e
-        raise DRb::DRbConnError, e.message
-      end
-    end
-
-    def make_request(method_name, method_params, first_try)
-      request = JsonRpcRequest.new(method_name, method_params, @id)
-      @id += 1
-
-      @request_data = request.to_json(:allow_nan => true)
+    # 
+    def make_request(data:)
+      headers = {
+        'User-Agent' => USER_AGENT,
+        'Content-Type' => 'application/json-rpc',
+        'Authorization' => @authentication.token(),
+      }
       begin
-        STDOUT.puts "\nRequest:\n" if JsonDRb.debug?
-        STDOUT.puts @request_data if JsonDRb.debug?
-        @request_in_progress = true
-        if @x_csrf_token
-          headers = {'Content-Type' => 'application/json-rpc', 'X-Csrf-Token' => @x_csrf_token}
-        else
-          headers = {'Content-Type' => 'application/json-rpc'}
-        end
-        res = @http.post(@uri,
-                         :body   => @request_data,
-                         :header => headers)
-        @response_data = res.body
-        @request_in_progress = false
-        STDOUT.puts "Response:\n" if JsonDRb.debug?
-        STDOUT.puts @response_data if JsonDRb.debug?
-      rescue => e
-        disconnect()
-        return false if first_try
-        raise DRb::DRbConnError, e.message, e.backtrace
+        @log[0] = "Request: #{@uri.to_s} #{USER_AGENT} #{data.to_s}"
+        STDOUT.puts @log[0] if JsonDRb.debug?
+        resp = @http.post(@uri, :body => data, :header => headers)
+        @log[1] = "Response: #{resp.status} #{resp.headers} #{resp.body}"
+        @response_data = resp.body
+        STDOUT.puts @log[1] if JsonDRb.debug?
+        return resp.body
+      rescue StandardError => e
+        @log[2] = "Exception: #{e.class}, #{e.message}, #{e.backtrace}"
       end
-      @response_data
     end
 
-    def handle_response(response_data)
+    #
+    def handle_response(response:)
       # The code below will always either raise or return breaking out of the loop
-      if response_data and response_data.to_s.length > 0
-        response = JsonRpcResponse.from_json(response_data)
-        if JsonRpcErrorResponse === response
-          if response.error.data
-            raise Exception.from_hash(response.error.data)
-          else
-            raise "JsonDRb Error (#{response.error.code}): #{response.error.message}"
-          end
+      if JsonRpcErrorResponse === response
+        if response.error.data
+          raise Exception.from_hash(response.error.data)
         else
-          return response.result
+          raise "JsonDRb Error (#{response.error.code}): #{response.error.message}"
         end
       else
-        disconnect()
-        raise DRb::DRbConnError, "No response from server"
+        return response.result
       end
     end
-
   end # class JsonDRbObject
-
 end # module Cosmos

data/lib/cosmos/io/json_drb_rack.rb

@@ -1,25 +1,32 @@
 # encoding: ascii-8bit
 
-# Copyright 2017 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 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 'rack'
 
 module Cosmos
-
   # JsonDrbRack implements a rack application that can be served by a
   # webserver to process COSMOS json_drb requests via http.
   class JsonDrbRack
     # @param drb [JsonDRb] - An instance of the JsonDRb class that'll be used
     #   to process the JSON request and generate a response
-    def initialize(drb, system = nil)
+    def initialize(drb)
       @drb = drb
-      @system = system
     end
 
     # Handles a request.
@@ -30,64 +37,42 @@ module Cosmos
     def call(env)
       request = Rack::Request.new(env)
 
-      # ACL allow_addr? function takes address in the form returned by
-      # IPSocket.peeraddr.
-      req_addr = ["AF_INET", request.port, request.host.to_s, request.ip.to_s]
-      status = nil
-
-      if @drb.acl and !@drb.acl.allow_addr?(req_addr)
-        status       = 403
-        content_type = "text/plain"
-        body         = "Forbidden"
-      elsif request.post?
-        if @system
-          if @system.x_csrf_token and (request.env['HTTP_X_CSRF_TOKEN'] != @system.x_csrf_token)
-            status       = 403
-            content_type = "text/plain"
-            body         = "Forbidden: Bad X-Csrf-Token: #{request.env['HTTP_X_CSRF_TOKEN']}"
-          end
-          if !@system.allowed_hosts.include?(request.env['HTTP_HOST'])
-            status       = 403
-            content_type = "text/plain"
-            body         = "Forbidden: #{request.env['HTTP_HOST']} not in allowed hosts"
-          end
-          if request.env['HTTP_ORIGIN'] and !@system.allowed_origins.include?(request.env['HTTP_ORIGIN'])
-            status       = 403
-            content_type = "text/plain"
-            body         = "Forbidden: #{request.env['HTTP_ORIGIN']} not in allowed origins"
-          end
-        end
-
-        status, content_type, body = handle_post(request) unless status
+      if request.post?
+        request_headers = Hash[*request.env.select { |k, v| k.start_with? 'HTTP_' }.sort.flatten]
+        request_data = request.body.read
+        status, content_type, body = handle_post(request_data, request_headers)
       else
         status       = 405
         content_type = "text/plain"
         body         = "Request not allowed"
       end
 
-      return status, {'Content-Type' => content_type}, [body]
+      return status, { 'Content-Type' => content_type }, [body]
     end
 
     # Handles an http post.
     #
-    # @param request [Rack::Request] - A rack post request
+    # @param request_data [String] - A String of the post body from the request
+    # @param request_headers [Hash] - A Hash of the headers from the post request
     # @return [Integer, String, String] - Http response code, content type,
     #   response body.
-    def handle_post(request)
-      request_data = request.body.read
-      start_time = Time.now.sys
-      response_data, error_code = @drb.process_request(request_data, start_time)
+    def handle_post(request_data, request_headers)
+      response_data, error_code = @drb.process_request(
+        request_data: request_data,
+        request_headers: request_headers,
+        start_time: Time.now.sys
+      )
 
       # Convert json error code into html status code
       # see http://www.jsonrpc.org/historical/json-rpc-over-http.html#errors
       if error_code
         case error_code
-          when JsonRpcError::ErrorCode::PARSE_ERROR      then status = 500 # Internal server error
-          when JsonRpcError::ErrorCode::INVALID_REQUEST  then status = 400 # Bad request
-          when JsonRpcError::ErrorCode::METHOD_NOT_FOUND then status = 404 # Not found
-          when JsonRpcError::ErrorCode::INVALID_PARAMS   then status = 500 # Internal server error
-          when JsonRpcError::ErrorCode::INTERNAL_ERROR   then status = 500 # Internal server error
-          else status = 500 # Internal server error
+        when JsonRpcError::ErrorCode::PARSE_ERROR      then status = 500 # Internal server error
+        when JsonRpcError::ErrorCode::INVALID_REQUEST  then status = 400 # Bad request
+        when JsonRpcError::ErrorCode::METHOD_NOT_FOUND then status = 404 # Not found
+        when JsonRpcError::ErrorCode::INVALID_PARAMS   then status = 500 # Internal server error
+        when JsonRpcError::ErrorCode::INTERNAL_ERROR   then status = 500 # Internal server error
+        else status = 500 # Internal server error
         end
       else
         status = 200 # OK

data/lib/cosmos/io/json_rpc.rb

@@ -1,12 +1,21 @@
 # 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 'json'
 require 'date'
@@ -45,7 +54,7 @@ class String
   NON_ASCII_PRINTABLE = /[^\x21-\x7e\s]/
 
   def as_json(options = nil)
-    if self =~ NON_ASCII_PRINTABLE
+    if NON_ASCII_PRINTABLE.match?(self)
       self.to_json_raw_object
     else
       self
@@ -64,16 +73,17 @@ end
 class Float
   def self.json_create(object)
     case object['raw']
-      when "Infinity"  then  Float::INFINITY
-      when "-Infinity" then -Float::INFINITY
-      when "NaN"       then  Float::NAN
+    when "Infinity"  then  Float::INFINITY
+    when "-Infinity" then -Float::INFINITY
+    when "NaN"       then  Float::NAN
     end
   end
 
   def as_json(options = nil)
-    return {"json_class"=>Float, "raw"=>"Infinity"}  if self.infinite? ==  1
-    return {"json_class"=>Float, "raw"=>"-Infinity"} if self.infinite? == -1
-    return {"json_class"=>Float, "raw"=>"NaN"}       if self.nan?
+    return { "json_class" => Float, "raw" => "Infinity" }  if self.infinite? ==  1
+    return { "json_class" => Float, "raw" => "-Infinity" } if self.infinite? == -1
+    return { "json_class" => Float, "raw" => "NaN" }       if self.nan?
+
     return self
   end
 end
@@ -176,6 +186,7 @@ module Cosmos
     # @param other [JsonRpc] Another JsonRpc to compare hash values with
     def <=>(other)
       return nil unless other.respond_to?(:as_json)
+
       self.as_json <=> other.as_json
     end
 
@@ -199,14 +210,22 @@ module Cosmos
     # @param method_name [String] The name of the method to call
     # @param method_params [Array<String>] Array of strings which represent the
     #   parameters to send to the method
+    # @param keyword_params [Hash<String, Variable>] Hash of key value keyword params
     # @param id [Integer] The identifier which will be matched to the response
-    def initialize(method_name, method_params, id)
+    def initialize(method_name, method_params, keyword_params, id)
       super()
-      @hash['jsonrpc'.freeze] = "2.0".freeze
+      @hash['jsonrpc'.freeze] = '2.0'.freeze
       @hash['method'.freeze] = method_name.to_s
       if method_params and method_params.length != 0
         @hash['params'.freeze] = method_params
       end
+      if keyword_params and keyword_params.length != 0
+        symbolized = {}
+        keyword_params.each do |key, value|
+          symbolized[key.intern] = value
+        end
+        @hash['keyword_params'.freeze] = symbolized
+      end
       @hash['id'.freeze] = id.to_i
     end
 
@@ -221,6 +240,12 @@ module Cosmos
       @hash['params'.freeze] || []
     end
 
+    # @return [Hash<String, Variable>] Hash which represents the
+    #   keyword parameters to send to the method
+    def keyword_params
+      @hash['keyword_params'.freeze]
+    end
+
     # @return [Integer] The request identifier
     def id
       @hash['id'.freeze]
@@ -230,16 +255,17 @@ module Cosmos
     # must be 2.0 and the JSON must include the method and id members.
     #
     # @param request_data [String] JSON encoded string representing the request
+    # @param request_headers [Hash] Request Header to include the auth token
     # @return [JsonRpcRequest]
-    def self.from_json(request_data)
-      begin
-        hash = JSON.parse(request_data, :allow_nan => true, :create_additions => true)
-        # Verify the jsonrpc version is correct and there is a method and id
-        raise unless (hash['jsonrpc'.freeze] == "2.0".freeze && hash['method'.freeze] && hash['id'.freeze])
-        self.from_hash(hash)
-      rescue
-        raise "Invalid JSON-RPC 2.0 Request"
-      end
+    def self.from_json(request_data, request_headers)
+      hash = JSON.parse(request_data, :allow_nan => true, :create_additions => true)
+      hash['keyword_params']['token'] = request_headers['HTTP_AUTHORIZATION'] if request_headers['HTTP_AUTHORIZATION']
+      # Verify the jsonrpc version is correct and there is a method and id
+      raise unless hash['jsonrpc'.freeze] == "2.0".freeze && hash['method'.freeze] && hash['id'.freeze]
+
+      self.from_hash(hash)
+    rescue
+      raise "Invalid JSON-RPC 2.0 Request\n#{request_data.inspect}\n"
     end
 
     # Creates a JsonRpcRequest object from a Hash
@@ -248,13 +274,12 @@ module Cosmos
     #   and id
     # @return [JsonRpcRequest]
     def self.from_hash(hash)
-      self.new(hash['method'.freeze], hash['params'.freeze], hash['id'.freeze])
+      self.new(hash['method'.freeze], hash['params'.freeze], hash['keyword_params'.freeze], hash['id'.freeze])
     end
   end
 
   # Represents a JSON Remote Procedure Call Response
   class JsonRpcResponse < JsonRpc
-
     # @param id [Integer] The identifier which will be matched to the request
     def initialize(id)
       super()
@@ -269,7 +294,7 @@ module Cosmos
     # @param response_data [String] JSON encoded string representing the response
     # @return [JsonRpcResponse]
     def self.from_json(response_data)
-      msg = "Invalid JSON-RPC 2.0 Response: #{response_data.inspect}"
+      msg = "Invalid JSON-RPC 2.0 Response#{response_data.inspect}\n"
       begin
         hash = JSON.parse(response_data, :allow_nan => true, :create_additions => true)
       rescue
@@ -278,10 +303,12 @@ module Cosmos
 
       # Verify the jsonrpc version is correct and there is an ID
       raise msg unless hash['jsonrpc'.freeze] == "2.0".freeze and hash.key?('id'.freeze)
+
       # If there is a result this is probably a good response
       if hash.key?('result'.freeze)
         # Can't have an error key in a good response
         raise msg if hash.key?('error'.freeze)
+
         JsonRpcSuccessResponse.from_hash(hash)
       elsif hash.key?('error'.freeze)
         # There was an error key so create an error response
@@ -295,7 +322,6 @@ module Cosmos
 
   # Represents a JSON Remote Procedure Call Success Response
   class JsonRpcSuccessResponse < JsonRpcResponse
-
     # @param id [Integer] The identifier which will be matched to the request
     def initialize(result, id)
       super(id)
@@ -318,7 +344,6 @@ module Cosmos
 
   # Represents a JSON Remote Procedure Call Error Response
   class JsonRpcErrorResponse < JsonRpcResponse
-
     # @param error [JsonRpcError] The error object
     # @param id [Integer] The identifier which will be matched to the request
     def initialize(error, id)
@@ -342,7 +367,6 @@ module Cosmos
 
   # Represents a JSON Remote Procedure Call Error
   class JsonRpcError < JsonRpc
-
     # Enumeration of JSON RPC error codes
     class ErrorCode
       PARSE_ERROR      = -32700
@@ -350,6 +374,8 @@ module Cosmos
       METHOD_NOT_FOUND = -32601
       INVALID_PARAMS   = -32602
       INTERNAL_ERROR   = -32603
+      AUTH_ERROR       = -32500
+      FORBIDDEN_ERROR  = -32501
       OTHER_ERROR      = -1
     end
 
@@ -387,7 +413,7 @@ module Cosmos
       if hash['code'] and (hash['code'].to_i == hash['code']) and hash['message']
         self.new(hash['code'], hash['message'], hash['data'])
       else
-        raise "Invalid JSON-RPC 2.0 Error"
+        raise "Invalid JSON-RPC 2.0 Error\n#{hash.inspect}\n"
       end
     end
   end