openc3 5.10.1 → 5.11.0

data/lib/openc3/accessors/json_accessor.rb

@@ -13,7 +13,7 @@
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU Affero General Public License for more details.
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
 require 'json'
@@ -45,7 +45,7 @@ module OpenC3
         buffer.replace(JSON.generate(decoded, :allow_nan => true))
       end
 
-      return buffer
+      return value
     end
 
     def self.read_items(items, buffer)
@@ -78,7 +78,7 @@ module OpenC3
         buffer.replace(JSON.generate(decoded, :allow_nan => true))
       end
 
-      return buffer
+      return values
     end
 
     def self.write_item_internal(item, value, decoded)
@@ -130,5 +130,21 @@ module OpenC3
       end
       return decoded
     end
+
+    def enforce_encoding
+      return nil
+    end
+
+    def enforce_length
+      return false
+    end
+
+    def enforce_short_buffer_allowed
+      return true
+    end
+
+    def enforce_derived_write_conversion(item)
+      return true
+    end
   end
 end

data/lib/openc3/accessors/xml_accessor.rb

@@ -13,7 +13,7 @@
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU Affero General Public License for more details.
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
 require 'nokogiri'
@@ -33,6 +33,7 @@ module OpenC3
       node = doc.xpath(item.key).first
       node.content = value.to_s
       buffer.replace(doc_to_buffer(doc))
+      return value
     end
 
     def self.read_items(items, buffer)
@@ -56,6 +57,7 @@ module OpenC3
         node.content = values[index].to_s
       end
       buffer.replace(doc_to_buffer(doc))
+      return values
     end
 
     def self.buffer_to_doc(buffer)
@@ -66,5 +68,20 @@ module OpenC3
       doc.to_xml
     end
 
+    def enforce_encoding
+      return nil
+    end
+
+    def enforce_length
+      return false
+    end
+
+    def enforce_short_buffer_allowed
+      return true
+    end
+
+    def enforce_derived_write_conversion(item)
+      return true
+    end
   end
 end

data/lib/openc3/accessors.rb

@@ -13,14 +13,16 @@
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU Affero General Public License for more details.
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
 module OpenC3
   autoload(:Accessor, 'openc3/accessors/accessor.rb')
   autoload(:BinaryAccessor, 'openc3/accessors/binary_accessor.rb')
   autoload(:CborAccessor, 'openc3/accessors/cbor_accessor.rb')
+  autoload(:FormAccessor, 'openc3/accessors/form_accessor.rb')
   autoload(:HtmlAccessor, 'openc3/accessors/html_accessor.rb')
+  autoload(:HttpAccessor, 'openc3/accessors/http_accessor.rb')
   autoload(:JsonAccessor, 'openc3/accessors/json_accessor.rb')
   autoload(:XmlAccessor, 'openc3/accessors/xml_accessor.rb')
 end

data/lib/openc3/config/config_parser.rb

@@ -166,7 +166,7 @@ module OpenC3
         options[:locals].each { |key, value| b.local_variable_set(key, value) }
       end
 
-      return ERB.new(read_file(template_name), trim_mode: "-").result(b)
+      return ERB.new(read_file(template_name).comment_erb(), trim_mode: "-").result(b)
     end
 
     # Can be called during parsing to read a referenced file
@@ -178,7 +178,7 @@ module OpenC3
         path = File.join(File.dirname(@filename), filename)
       end
       OpenC3.set_working_dir(File.dirname(path)) do
-        return File.read(path)
+        return File.read(path).force_encoding("UTF-8")
       end
     end
 
@@ -385,10 +385,10 @@ module OpenC3
         output = nil
         if run_erb
           OpenC3.set_working_dir(File.dirname(filename)) do
-            output = ERB.new(File.read(filename), trim_mode: "-").result(binding.set_variables(variables))
+            output = ERB.new(File.read(filename).force_encoding("UTF-8").comment_erb(), trim_mode: "-").result(binding.set_variables(variables))
           end
         else
-          output = File.read(filename)
+          output = File.read(filename).force_encoding("UTF-8")
         end
       rescue => e
         # The first line of the backtrace indicates the line where the ERB
@@ -453,8 +453,10 @@ module OpenC3
           message += "\n#{File.basename(error.filename)}:#{error.line_number}: #{error.line}"
           message += "\nError: #{error.message}"
           message += "\nUsage: #{error.usage}" unless error.usage.empty?
+          message += "\nBacktrace:"
+          message += "\n#{error.backtrace.join("\n")}"
         else
-          message += "\n#{error.message}"
+          message += "\n#{error.formatted}"
         end
         message += "\n"
       end

data/lib/openc3/config/meta_config_parser.rb

@@ -17,7 +17,7 @@
 # All changes Copyright 2022, OpenC3, Inc.
 # All Rights Reserved
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
 require 'erb'

data/lib/openc3/core_ext/string.rb

@@ -389,4 +389,19 @@ class String
     end
   end
 
-end # class String
+  def comment_erb
+    output = self.lines.collect! do |line|
+      # If we have a commented out line that starts with #
+      # but not followed by % (allows for disabling ERB comments),
+      # which contains an ERB statement (<% ...)
+      # then comment out the ERB statement (<%# ...).
+      # We explicitly don't comment out trailing ERB statements
+      # as that is not typical and is difficult to regex
+      if line =~ /^\s*#[^%]*<%/
+        line.gsub!('<%', '<%#')
+      end
+      line
+    end
+    return output.join("")
+  end
+end

data/lib/openc3/interfaces/http_client_interface.rb

@@ -0,0 +1,202 @@
+# encoding: ascii-8bit
+
+# Copyright 2023 OpenC3, Inc.
+# 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 file may also be used under the terms of a commercial license
+# if purchased from OpenC3, Inc.
+
+require 'openc3/interfaces/interface'
+require 'openc3/config/config_parser'
+require 'faraday'
+require 'faraday/follow_redirects'
+require 'openc3/accessors/http_accessor'
+
+# TODO: Header Log Filtering? File Uploads? Authorization from secrets?
+
+module OpenC3
+  class HttpClientInterface < Interface
+    # @param hostname [String] HTTP/HTTPS server to connect to
+    # @param port [Integer] HTTP/HTTPS port
+    # @param protocol [String] http or https
+    def initialize(hostname, port = 80, protocol = 'http', write_timeout = 5, read_timeout = nil, connect_timeout = 5, include_request_in_response = false)
+      super()
+      @hostname = hostname
+      @port = Integer(port)
+      @protocol = protocol
+      if (port == 80 and protocol == 'http') or (port == 443 and protocol == 'https')
+        @url = "#{protocol}://#{hostname}"
+      else
+        @url = "#{protocol}://#{hostname}:#{port}"
+      end
+      @write_timeout = ConfigParser.handle_nil(write_timeout)
+      @write_timeout = Float(@write_timeout) if @write_timeout
+      @read_timeout = ConfigParser.handle_nil(read_timeout)
+      @read_timeout = Float(@read_timeout) if @read_timeout
+      @connect_timeout = ConfigParser.handle_nil(connect_timeout)
+      @connect_timeout = Float(@connect_timeout) if @connect_timeout
+      @include_request_in_response = ConfigParser.handle_true_false(include_request_in_response)
+
+      @response_queue = Queue.new
+    end
+
+    # Connects the interface to its target(s)
+    def connect
+      # Per https://github.com/lostisland/faraday/blob/main/lib/faraday/options/env.rb
+      # :timeout       - time limit for the entire request (Integer in seconds)
+      # :open_timeout  - time limit for just the connection phase (e.g. handshake) (Integer in seconds)
+      # :read_timeout  - time limit for the first response byte received from the server (Integer in seconds)
+      # :write_timeout - time limit for the client to send the request to the server (Integer in seconds)
+      request = {}
+      request['open_timeout'] = @connect_timeout if @connect_timeout
+      request['read_timeout'] = @read_timeout if @read_timeout
+      request['write_timeout'] = @write_timeout if @write_timeout
+      @http = Faraday.new(request: request) do |f|
+        f.response :follow_redirects # use Faraday::FollowRedirects::Middleware
+        f.adapter :net_http # adds the adapter to the connection, defaults to `Faraday.default_adapter`
+      end
+      super()
+    end
+
+    def connected?
+      if @http
+        return true
+      else
+        return false
+      end
+    end
+
+    # Disconnects the interface from its target(s)
+    def disconnect
+      @http.close if @http
+      @http = nil
+      while @response_queue.length > 0
+        @response_queue.pop
+      end
+      super()
+      @response_queue.push(nil)
+    end
+
+    # Reads from the socket if the read_port is defined
+    def read_interface
+      # Get the Faraday Response
+      data, extra = @response_queue.pop
+      return nil if data.nil?
+
+      read_interface_base(data, extra)
+      return data, extra
+    end
+
+    # Writes to the socket
+    # @param data [Hash] For the HTTP Interface, data is a hash with the needed request info
+    def write_interface(data, extra = nil)
+      extra ||= {}
+      queries = extra['HTTP_QUERIES']
+      queries ||= {}
+      headers = extra['HTTP_HEADERS']
+      headers ||= {}
+      uri = extra['HTTP_URI']
+      method = extra['HTTP_METHOD']
+
+      resp = nil
+      case method
+      when 'get'
+        resp = @http.get(uri, queries, headers)
+      when 'put'
+        resp = @http.put(uri) do |req|
+          req.params = queries
+          req.headers = headers
+          req.body = data
+        end
+      when 'delete'
+        resp = @http.delete(uri, queries, headers)
+      else # 'post'
+        resp = @http.post(uri) do |req|
+          req.params = queries
+          req.headers = headers
+          req.body = data
+        end
+      end
+
+      # Normalize Response into simple hash
+      response_data = nil
+      response_extra = {}
+      if resp
+        response_extra['HTTP_REQUEST'] = [data, extra]
+        if resp.headers and resp.headers.length > 0
+          response_extra['HTTP_HEADERS'] = resp.headers
+        end
+        response_extra['HTTP_STATUS'] = resp.status
+        response_data = resp.body
+        response_data ||= '' # Ensure an empty string if we got a response but no data
+      end
+
+      @response_queue.push([response_data, response_extra])
+
+      write_interface_base(data, extra)
+      return data, extra
+    end
+
+    # Called to convert the read data into a OpenC3 Packet object
+    #
+    # @param data [String] Raw packet data
+    # @return [Packet] OpenC3 Packet with buffer filled with data
+    def convert_data_to_packet(data, extra = nil)
+      packet = Packet.new(nil, nil, :BIG_ENDIAN, nil, data.to_s)
+      packet.accessor = HttpAccessor.new(packet)
+      if extra
+        # Identify the response
+        request_target_name = extra['HTTP_REQUEST_TARGET_NAME']
+        if request_target_name
+          request_target_name = request_target_name.to_s.upcase
+          response_packet_name = extra['HTTP_PACKET']
+          error_packet_name = extra['HTTP_ERROR_PACKET']
+          status = extra['HTTP_STATUS'].to_i
+          if status >= 300 and error_packet_name
+            # Handle error special case response packet
+            packet.target_name = request_target_name
+            packet.packet_name = error_packet_name.to_s.upcase
+          else
+            if response_packet_name
+              packet.target_name = request_target_name
+              packet.packet_name = response_packet_name.to_s.upcase
+            end
+          end
+        end
+
+        if not @include_request_in_response
+          extra.delete("HTTP_REQUEST")
+        end
+        extra.delete("HTTP_REQUEST_TARGET_NAME")
+        extra.delete("HTTP_REQUEST_PACKET_NAME")
+        packet.extra = extra
+      end
+
+      return packet
+    end
+
+    # Called to convert a packet into the data to send
+    #
+    # @param packet [Packet] Packet to extract data from
+    # @return data
+    def convert_packet_to_data(packet)
+      extra = packet.extra
+      extra ||= {}
+      data = packet.buffer(true) # Copy buffer so logged command isn't modified
+      extra['HTTP_URI'] = URI("#{@url}#{packet.read('HTTP_PATH')}").to_s
+      extra['HTTP_REQUEST_TARGET_NAME'] = packet.target_name
+      extra['HTTP_REQUEST_PACKET_NAME'] = packet.packet_name
+      return data, extra
+    end
+  end
+end

data/lib/openc3/interfaces/http_server_interface.rb

@@ -0,0 +1,183 @@
+# encoding: ascii-8bit
+
+# Copyright 2023 OpenC3, Inc.
+# 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 file may also be used under the terms of a commercial license
+# if purchased from OpenC3, Inc.
+
+require 'openc3/interfaces/interface'
+require 'openc3/config/config_parser'
+require 'openc3/accessors/http_accessor'
+require 'webrick'
+
+module OpenC3
+  class HttpServerInterface < Interface
+    # @param port [Integer] HTTP port
+    def initialize(port = 80)
+      super()
+      @port = Integer(port)
+      @server = nil
+      @request_queue = Queue.new
+    end
+
+    # Connects the interface to its target(s)
+    def connect
+      @server = WEBrick::HTTPServer.new :Port => @port
+      @request_queue = Queue.new
+
+      # Create a response hook for every command packet
+      @target_names.each do |target_name|
+        System.commands.packets(target_name).each do |packet_name, packet|
+          packet.restore_defaults
+          path = nil
+          begin
+            path = packet.read('HTTP_PATH')
+          rescue => err
+            # No HTTP_PATH is an error
+            Logger.error("HttpServerInterface Packet #{target_name} #{packet_name} unable to read HTTP_PATH\n#{err.formatted}")
+          end
+          if path
+            @server.mount_proc path do |req, res|
+              # Build the Response
+              begin
+                status = packet.read('HTTP_STATUS')
+                if status
+                  res.status = status
+                end
+              rescue
+                # No HTTP_STATUS - Leave at default
+              end
+
+              if packet.extra
+                headers = packet.extra['HTTP_HEADERS']
+                if headers
+                  headers.each do |key, value|
+                    res[key] = value
+                  end
+                end
+              end
+
+              res.body = packet.buffer
+
+              # Save the Request
+              packet_name = nil
+              begin
+                packet_name = packet.read('HTTP_PACKET')
+              rescue
+                # No packet name means dont save the request as telemetry
+              end
+              if packet_name
+                data = req.body.to_s.dup # Dup to remove frozen
+                extra = {}
+                extra['HTTP_REQUEST_TARGET_NAME'] = target_name
+                extra['HTTP_REQUEST_PACKET_NAME'] = packet_name
+
+                headers = req.header
+                if headers
+                  extra['HTTP_HEADERS'] = {}
+                  headers.each do |key, value|
+                    extra['HTTP_HEADERS'][key.downcase] = value
+                  end
+                end
+
+                queries = req.query
+                if queries
+                  extra['HTTP_QUERIES'] = {}
+                  queries.each do |key, value|
+                    extra['HTTP_QUERIES'][key] = value
+                  end
+                end
+
+                @request_queue << [data, extra]
+              end
+            end
+          end
+        end
+      end
+
+      super()
+
+      Thread.new do
+        # This blocks, but will be unblocked by server.shutdown called in disconnect()
+        @server.start
+      end
+    end
+
+    def connected?
+      if @server
+        return true
+      else
+        return false
+      end
+    end
+
+    # Disconnects the interface from its target(s)
+    def disconnect
+      @server.shutdown if @server
+      @server = nil
+      while @request_queue.length > 0
+        @request_queue.pop
+      end
+      super()
+      @request_queue.push(nil)
+    end
+
+    # Reads from the socket if the read_port is defined
+    def read_interface
+      # Get the Faraday Response
+      data, extra = @request_queue.pop
+      return nil if data.nil?
+
+      read_interface_base(data, extra)
+      return data, extra
+    end
+
+    # Writes to the socket
+    # @param data [Hash] For the HTTP Interface, data is a hash with the needed request info
+    def write_interface(data, extra = nil)
+      raise "Commands cannot be sent to HttpServerInterface"
+    end
+
+    # Called to convert the read data into a OpenC3 Packet object
+    #
+    # @param data [String] Raw packet data
+    # @return [Packet] OpenC3 Packet with buffer filled with data
+    def convert_data_to_packet(data, extra = nil)
+      packet = Packet.new(nil, nil, :BIG_ENDIAN, nil, data.to_s)
+      packet.accessor = HttpAccessor.new(packet)
+      if extra
+        # Identify the response
+        request_target_name = extra['HTTP_REQUEST_TARGET_NAME']
+        request_packet_name = extra['HTTP_REQUEST_PACKET_NAME']
+        if request_target_name and request_packet_name
+          packet.target_name = request_target_name.to_s.upcase
+          packet.packet_name = request_packet_name.to_s.upcase
+        end
+        extra.delete("HTTP_REQUEST_TARGET_NAME")
+        extra.delete("HTTP_REQUEST_PACKET_NAME")
+        packet.extra = extra
+      end
+
+      return packet
+    end
+
+    # Called to convert a packet into the data to send
+    #
+    # @param packet [Packet] Packet to extract data from
+    # @return data
+    def convert_packet_to_data(packet)
+      raise "Commands cannot be sent to HttpServerInterface"
+    end
+  end
+end