adams-visiona 1.0.0

data/lib/cosmos/io/json_drb.rb

@@ -0,0 +1,307 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 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
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'thread'
+require 'socket'
+require 'json'
+require 'drb/acl'
+require 'drb/drb'
+require 'set'
+require 'cosmos/io/json_rpc'
+require 'cosmos/io/json_drb_rack'
+require 'rack/handler/puma'
+
+# Add methods to the Puma::Launcher and Puma::Single class so we can tell
+# if the server has been started.
+module Puma
+  class Launcher
+    def running
+      @runner and @runner.running
+    end
+  end
+  class Runner
+  end
+  class Single < Runner
+    def running
+      @server and @server.running
+    end
+  end
+end
+
+module Cosmos
+  # JsonDRb implements the JSON-RPC 2.0 Specification to provide an interface
+  # for both internal and external tools to access the COSMOS server. It
+  # provides methods to install an access control list to control access to the
+  # API. It also limits the available methods to a known list of allowable API
+  # methods.
+  class JsonDRb
+    # Minimum amount of time in seconds to receive the JSON request,
+    # process it, and send the response. Requests for less than this amount
+    # will be set to the minimum
+    MINIMUM_REQUEST_TIME = 0.0001
+    STOP_SERVICE_TIMEOUT = 10.0 # seconds to wait when stopping the service
+    PUMA_THREAD_TIMEOUT  = 10.0 # seconds to wait for the puma threads to die
+    SERVER_START_TIMEOUT = 15.0 # seconds to wait for the server to start
+
+    @@debug = false
+
+    # @return [Integer] The number of JSON-RPC requests processed
+    attr_accessor :request_count
+    # @return [Array<String>] List of methods that should be allowed
+    attr_accessor :method_whitelist
+    # @return [ACL] The access control list
+    attr_accessor :acl
+
+    def initialize
+      @thread = nil
+      @acl = nil
+      @object = nil
+      @method_whitelist = nil
+      @request_count = 0
+      @request_times = []
+      @request_times_index = 0
+      @request_mutex = Mutex.new
+      @server = nil
+      @server_mutex = Mutex.new
+    end
+
+    # Returns the number of connected clients
+    # @return [Integer] The number of connected clients
+    def num_clients
+      clients = 0
+      @server_mutex.synchronize do
+        if @server
+          # @server.stats() returns a string like: { "backlog": 0, "running": 0 }
+          # "running" indicates the number of server threads running, and
+          # therefore the number of clients connected.
+          stats = @server.stats()
+          stats =~ /"running": \d*/
+          clients = $&.split(":")[1].to_i
+        end
+      end
+      return clients
+    end
+
+    # Stops the DRb service by closing the socket and the processing thread
+    def stop_service
+      # Kill the server thread
+      # parameters are owner, thread, graceful_timeout, timeout_interval, hard_timeout
+      Cosmos.kill_thread(self, @thread, STOP_SERVICE_TIMEOUT, 0.1, STOP_SERVICE_TIMEOUT)
+      @thread = nil
+      @server_mutex.synchronize do
+        @server = nil
+      end
+    end
+
+    # Gracefully kill the thread
+    def graceful_kill
+      @server_mutex.synchronize do
+        begin
+          @server.stop if @server and @server.running
+        rescue
+        end
+      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)
+      server_started = false
+      @server_mutex.synchronize do
+        server_started = true if @server
+      end
+      return if server_started
+
+      if hostname and port and object
+        @object = object
+        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
+
+            # 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
+          # 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)
+          end
+        end
+
+        # Wait for the server to be started in the thread before returning.
+        start_time = Time.now
+        while ((Time.now - start_time) < SERVER_START_TIMEOUT) and !server_started
+          sleep(0.1)
+          @server_mutex.synchronize do
+            server_started = true if @server and @server.running
+          end
+        end
+        raise "JsonDRb http server could not be started." unless server_started
+
+      elsif hostname or port or object
+        raise "0 or 3 parameters must be given"
+      else
+        # Client - Noop
+      end
+    end
+
+    # @return [Thread] The server thread listening for incoming requests
+    def thread
+      @thread
+    end
+
+    # 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
+    # times are used by the {#average_request_time} method to calculate an
+    # average request time.
+    #
+    # @param request_time [Float] Time in seconds for the data transmission
+    def add_request_time(request_time)
+      @request_mutex.synchronize do
+        request_time = MINIMUM_REQUEST_TIME if request_time < MINIMUM_REQUEST_TIME
+        @request_times[@request_times_index] = request_time
+        @request_times_index += 1
+        @request_times_index = 0 if @request_times_index >= 100
+      end
+    end
+
+    # @return [Float] The average time in seconds for a JSON DRb request to be
+    #   processed and the response sent.
+    def average_request_time
+      avg = 0
+      @request_mutex.synchronize do
+        avg = @request_times.mean
+      end
+      avg
+    end
+
+    # @return [Boolean] Whether debug messages are enabled
+    def self.debug?
+      @@debug
+    end
+
+    # @param value [Boolean] Whether to enable debug messages
+    def self.debug=(value)
+      @@debug = value
+    end
+
+    # Process the JSON request data, execute the method, and create a response.
+    #
+    # @param request_data [String] The JSON encoded 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)
+      @request_count += 1
+      STDOUT.puts request_data if JsonDRb.debug?
+      begin
+        request = JsonRpcRequest.from_json(request_data)
+        response = nil
+        error_code = nil
+        response_data = nil
+
+        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.id
+              response = JsonRpcSuccessResponse.new(result, request.id)
+            end
+          rescue Exception => error
+            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)
+              elsif ArgumentError === error
+                error_code = JsonRpcError::ErrorCode::INVALID_PARAMS
+                response = JsonRpcErrorResponse.new(
+                  JsonRpcError.new(error_code, "Invalid params", error), request.id)
+              else
+                error_code = JsonRpcError::ErrorCode::OTHER_ERROR
+                response = JsonRpcErrorResponse.new(
+                  JsonRpcError.new(error_code, error.message, error), request.id)
+              end
+            end
+          end
+        else
+          if request.id
+            error_code = JsonRpcError::ErrorCode::OTHER_ERROR
+            response = JsonRpcErrorResponse.new(
+              JsonRpcError.new(error_code, "Cannot call unauthorized methods"), request.id)
+          end
+        end
+        response_data = process_response(response, start_time) if response
+        return response_data, error_code
+      rescue => error
+        error_code = JsonRpcError::ErrorCode::INVALID_REQUEST
+        response = JsonRpcErrorResponse.new(JsonRpcError.new(error_code, "Invalid Request", error), nil)
+        response_data = process_response(response, start_time)
+        return response_data, error_code
+      end
+    end
+
+    protected
+
+    def process_response(response, start_time)
+      response_data = response.to_json(:allow_nan => true)
+      STDOUT.puts response_data if JsonDRb.debug?
+      end_time = Time.now.sys
+      request_time = end_time - start_time
+      add_request_time(request_time)
+      return response_data
+    end
+
+  end
+end

data/lib/cosmos/io/json_drb_object.rb

@@ -0,0 +1,172 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 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
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'cosmos'
+require 'thread'
+require 'socket'
+require 'json'
+require 'drb/acl'
+require 'drb/drb'
+require 'cosmos/io/json_drb'
+require 'uri'
+require 'httpclient'
+
+module Cosmos
+
+  # 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 JsonDRbObject can be used to call server methods directly:
+  #
+  #   server = JsonDRbObject('127.0.0.1', 7777)
+  #   server.cmd(*args)
+  #
+  class JsonDRbObject
+    attr_reader :request_data
+    attr_reader :response_data
+
+    # @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
+
+    # Permanently disconnects from the http server
+    def shutdown
+      @shutdown = true
+      disconnect()
+    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
+    # @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)
+      @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
+            disconnect()
+            was_first_try = first_try
+            first_try = false
+            next if was_first_try
+          end
+          return handle_response(response)
+        end
+      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)
+      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
+      end
+      @response_data
+    end
+
+    def handle_response(response_data)
+      # 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
+        else
+          return response.result
+        end
+      else
+        disconnect()
+        raise DRb::DRbConnError, "No response from server"
+      end
+    end
+
+  end # class JsonDRbObject
+
+end # module Cosmos

data/lib/cosmos/io/json_drb_rack.rb

@@ -0,0 +1,99 @@
+# encoding: ascii-8bit
+
+# Copyright 2017 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
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+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)
+      @drb = drb
+      @system = system
+    end
+
+    # Handles a request.
+    #
+    # @param env [Hash] - A rack env hash, can be turned into a Rack::Request
+    # @return [Integer, Hash, [String]] - Http response code, content headers,
+    #   response body
+    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
+      else
+        status       = 405
+        content_type = "text/plain"
+        body         = "Request not allowed"
+      end
+
+      return status, {'Content-Type' => content_type}, [body]
+    end
+
+    # Handles an http post.
+    #
+    # @param request [Rack::Request] - A rack 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)
+
+      # 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
+        end
+      else
+        status = 200 # OK
+      end
+
+      return status, "application/json-rpc", response_data
+    end
+  end
+end