openc3 5.13.0 → 5.14.1

data/lib/openc3/models/target_model.rb

@@ -742,7 +742,7 @@ module OpenC3
       end
     end
 
-    def update_store(system)
+    def update_target_model(system)
       target = system.targets[@name]
 
       # Add in the information from the target and update
@@ -754,10 +754,11 @@ module OpenC3
       @tlm_unique_id_mode = target.tlm_unique_id_mode
       @limits_groups = system.limits.groups.keys
       update()
+    end
 
-      # Store Packet Definitions
-      system.telemetry.all.each do |target_name, packets|
-        Store.del("#{@scope}__openc3tlm__#{target_name}")
+    def update_store_telemetry(packet_hash, clear_old: true)
+      packet_hash.each do |target_name, packets|
+        Store.del("#{@scope}__openc3tlm__#{target_name}") if clear_old
         packets.each do |packet_name, packet|
           Logger.info "Configuring tlm packet: #{target_name} #{packet_name}"
           begin
@@ -773,8 +774,11 @@ module OpenC3
           CvtModel.set(json_hash, target_name: packet.target_name, packet_name: packet.packet_name, scope: @scope)
         end
       end
-      system.commands.all.each do |target_name, packets|
-        Store.del("#{@scope}__openc3cmd__#{target_name}")
+    end
+
+    def update_store_commands(packet_hash, clear_old: true)
+      packet_hash.each do |target_name, packets|
+        Store.del("#{@scope}__openc3cmd__#{target_name}") if clear_old
         packets.each do |packet_name, packet|
           Logger.info "Configuring cmd packet: #{target_name} #{packet_name}"
           begin
@@ -785,7 +789,9 @@ module OpenC3
           end
         end
       end
-      # Store Limits Groups
+    end
+
+    def update_store_limits_groups(system)
       system.limits.groups.each do |group, items|
         begin
           Store.hset("#{@scope}__limits_groups", group, JSON.generate(items))
@@ -794,23 +800,113 @@ module OpenC3
           raise err
         end
       end
-      # Merge in Limits Sets
+    end
+
+    def update_store_limits_sets(system)
       sets = Store.hgetall("#{@scope}__limits_sets")
       sets ||= {}
       system.limits.sets.each do |set|
         sets[set.to_s] = "false" unless sets.key?(set.to_s)
       end
       Store.hmset("#{@scope}__limits_sets", *sets)
+    end
 
+    def update_store_item_map
       # Create item_map
       item_map_key = "#{@scope}__#{@name}__item_to_packet_map"
       item_map = self.class.build_item_to_packet_map(@name, scope: @scope)
       Store.set(item_map_key, JSON.generate(item_map, :allow_nan => true))
       @@item_map_cache[@name] = [Time.now, item_map]
+    end
 
+    def update_store(system, clear_old: true)
+      update_target_model(system)
+      update_store_telemetry(system.telemetry.all, clear_old: clear_old)
+      update_store_commands(system.commands.all, clear_old: clear_old)
+      update_store_limits_groups(system)
+      update_store_limits_sets(system)
+      update_store_item_map()
       return system
     end
 
+    def dynamic_update(packets, cmd_or_tlm = :TELEMETRY, filename = "dynamic_tlm.txt")
+      # Build hash of targets/packets
+      packet_hash = {}
+      packets.each do |packet|
+        target_name = packet.target_name.upcase
+        packet_hash[target_name] ||= {}
+        packet_name = packet.packet_name.upcase
+        packet_hash[target_name][packet_name] = packet
+      end
+
+      # Update Redis
+      if cmd_or_tlm == :TELEMETRY
+        update_store_telemetry(packet_hash, clear_old: false)
+        update_store_item_map()
+      else
+        update_store_commands(packet_hash, clear_old: false)
+      end
+
+      # Build dynamic file for cmd_tlm
+      configs = {}
+      packets.each do |packet|
+        target_name = packet.target_name.upcase
+        configs[target_name] ||= ""
+        config = configs[target_name]
+        config << packet.to_config(cmd_or_tlm)
+        config << "\n"
+      end
+      configs.each do |target_name, config|
+        begin
+          bucket_key = "#{@scope}/targets_modified/#{target_name}/cmd_tlm/#{filename}"
+          client = Bucket.getClient()
+          client.put_object(
+            # Use targets_modified to save modifications
+            # This keeps the original target clean (read-only)
+            bucket: ENV['OPENC3_CONFIG_BUCKET'],
+            key: bucket_key,
+            body: config
+          )
+        end
+      end
+
+      # Inform microservices of new topics
+      # Need to tell loggers to log, and decom to decom
+      # We do this for no downtime
+      raw_topics = []
+      decom_topics = []
+      packets.each do |packet|
+        if cmd_or_tlm == :TELEMETRY
+          raw_topics << "#{@scope}__TELEMETRY__{#{@name}}__#{packet.packet_name.upcase}"
+          decom_topics << "#{@scope}__DECOM__{#{@name}}__#{packet.packet_name.upcase}"
+        else
+          raw_topics << "#{@scope}__COMMAND__{#{@name}}__#{packet.packet_name.upcase}"
+          decom_topics << "#{@scope}__DECOMCMD__{#{@name}}__#{packet.packet_name.upcase}"
+        end
+      end
+      if cmd_or_tlm == :TELEMETRY
+        Topic.write_topic("MICROSERVICE__#{@scope}__PACKETLOG__#{@name}", {'command' => 'ADD_TOPICS', 'topics' => raw_topics.as_json.to_json})
+        add_topics_to_microservice("#{@scope}__PACKETLOG__#{@name}", raw_topics)
+        Topic.write_topic("MICROSERVICE__#{@scope}__DECOMLOG__#{@name}", {'command' => 'ADD_TOPICS', 'topics' => decom_topics.as_json.to_json})
+        add_topics_to_microservice("#{@scope}__DECOMLOG__#{@name}", decom_topics)
+        Topic.write_topic("MICROSERVICE__#{@scope}__DECOM__#{@name}", {'command' => 'ADD_TOPICS', 'topics' => raw_topics.as_json.to_json})
+        add_topics_to_microservice("#{@scope}__DECOM__#{@name}", raw_topics)
+      else
+        Topic.write_topic("MICROSERVICE__#{@scope}__COMMANDLOG__#{@name}", {'command' => 'ADD_TOPICS', 'topics' => raw_topics.as_json.to_json})
+        add_topics_to_microservice("#{@scope}__COMMANDLOG__#{@name}", raw_topics)
+        Topic.write_topic("MICROSERVICE__#{@scope}__DECOMCMDLOG__#{@name}", {'command' => 'ADD_TOPICS', 'topics' => decom_topics.as_json.to_json})
+        add_topics_to_microservice("#{@scope}__DECOMCMDLOG__#{@name}", decom_topics)
+      end
+    end
+
+    def add_topics_to_microservice(microservice_name, topics)
+      model = MicroserviceModel.get_model(name: microservice_name, scope: @scope)
+      model.topics.concat(topics)
+      model.topics.uniq!
+      model.ignore_changes = true # Don't restart the microservice right now
+      model.update
+    end
+
     def deploy_commmandlog_microservice(gem_path, variables, topics, instance = nil, parent = nil)
       microservice_name = "#{@scope}__COMMANDLOG#{instance}__#{@name}"
       microservice = MicroserviceModel.new(
@@ -990,6 +1086,7 @@ module OpenC3
           cmd: ["ruby", "multi_microservice.rb", *@children],
           work_dir: '/openc3/lib/openc3/microservices',
           plugin: @plugin,
+          needs_dependencies: @needs_dependencies,
           scope: @scope
         )
         microservice.create
@@ -1048,7 +1145,6 @@ module OpenC3
       decom_command_topic_list = []
       packet_topic_list = []
       decom_topic_list = []
-      reduced_topic_list = []
       begin
         system.commands.packets(@name).each do |packet_name, packet|
           command_topic_list << "#{@scope}__COMMAND__{#{@name}}__#{packet_name}"
@@ -1061,9 +1157,6 @@ module OpenC3
         system.telemetry.packets(@name).each do |packet_name, packet|
           packet_topic_list << "#{@scope}__TELEMETRY__{#{@name}}__#{packet_name}"
           decom_topic_list  << "#{@scope}__DECOM__{#{@name}}__#{packet_name}"
-          reduced_topic_list << "#{@scope}__REDUCED_MINUTE__{#{@name}}__#{packet_name}"
-          reduced_topic_list << "#{@scope}__REDUCED_HOUR__{#{@name}}__#{packet_name}"
-          reduced_topic_list << "#{@scope}__REDUCED_DAY__{#{@name}}__#{packet_name}"
         end
       rescue
         # No telemetry packets for this target

data/lib/openc3/operators/microservice_operator.rb

@@ -98,28 +98,30 @@ module OpenC3
           previous_parent = @previous_microservices[microservice_name]['parent']
           if @previous_microservices[microservice_name] != microservice_config
             # CHANGED
-            scope = microservice_name.split("__")[0]
-            Logger.info("Changed microservice detected: #{microservice_name}\nWas: #{@previous_microservices[microservice_name]}\nIs: #{microservice_config}", scope: scope)
-            if parent or previous_parent
-              if parent == previous_parent
-                # Same Parent - Respawn parent
-                @changed_microservices[parent] = @microservices[parent] if @microservices[parent] and @previous_microservices[parent]
-              elsif parent and previous_parent
-                # Parent changed - Respawn both parents
-                @changed_microservices[parent] = @microservices[parent] if @microservices[parent] and @previous_microservices[parent]
-                @changed_microservices[previous_parent] = @microservices[previous_parent] if @microservices[previous_parent] and @previous_microservices[previous_parent]
-              elsif parent
-                # Moved under a parent - Respawn parent and kill standalone
-                @changed_microservices[parent] = @microservices[parent] if @microservices[parent] and @previous_microservices[parent]
-                @removed_microservices[microservice_name] = microservice_config
-              else # previous_parent
-                # Moved to standalone - Respawn previous parent and make new
-                @changed_microservices[previous_parent] = @microservices[previous_parent] if @microservices[previous_parent] and @previous_microservices[previous_parent]
-                @new_microservices[microservice_name] = microservice_config
+            if not microservice_config['ignore_changes']
+              scope = microservice_name.split("__")[0]
+              Logger.info("Changed microservice detected: #{microservice_name}\nWas: #{@previous_microservices[microservice_name]}\nIs: #{microservice_config}", scope: scope)
+              if parent or previous_parent
+                if parent == previous_parent
+                  # Same Parent - Respawn parent
+                  @changed_microservices[parent] = @microservices[parent] if @microservices[parent] and @previous_microservices[parent]
+                elsif parent and previous_parent
+                  # Parent changed - Respawn both parents
+                  @changed_microservices[parent] = @microservices[parent] if @microservices[parent] and @previous_microservices[parent]
+                  @changed_microservices[previous_parent] = @microservices[previous_parent] if @microservices[previous_parent] and @previous_microservices[previous_parent]
+                elsif parent
+                  # Moved under a parent - Respawn parent and kill standalone
+                  @changed_microservices[parent] = @microservices[parent] if @microservices[parent] and @previous_microservices[parent]
+                  @removed_microservices[microservice_name] = microservice_config
+                else # previous_parent
+                  # Moved to standalone - Respawn previous parent and make new
+                  @changed_microservices[previous_parent] = @microservices[previous_parent] if @microservices[previous_parent] and @previous_microservices[previous_parent]
+                  @new_microservices[microservice_name] = microservice_config
+                end
+              else
+                # Respawn regular microservice
+                @changed_microservices[microservice_name] = microservice_config
               end
-            else
-              # Respawn regular microservice
-              @changed_microservices[microservice_name] = microservice_config
             end
           end
         else

data/lib/openc3/packets/commands.rb

@@ -303,6 +303,10 @@ module OpenC3
       @config.commands
     end
 
+    def dynamic_add_packet(packet, affect_ids: false)
+      @config.dynamic_add_packet(packet, :COMMAND, affect_ids: affect_ids)
+    end
+
     protected
 
     def set_parameters(command, params, range_checking)

data/lib/openc3/packets/packet.rb

@@ -89,6 +89,18 @@ module OpenC3
     # @return [String] Base data for building packet
     attr_reader :template
 
+    # @return [Array<Target Name, Packet Name>] Related response packet
+    attr_accessor :response
+
+    # @return [Array<Target Name, Packet Name>] Related error response packet
+    attr_accessor :error_response
+
+    # @return [Array<Target Name, Screen Name>] Related telemetry screen
+    attr_accessor :screen
+
+    # @return [Array<Array<Target Name, Packet Name, Item Name>>] Related items
+    attr_accessor :related_items
+
     # Valid format types
     VALUE_TYPES = [:RAW, :CONVERTED, :FORMATTED, :WITH_UNITS]
 
@@ -297,6 +309,10 @@ module OpenC3
       @config_name
     end
 
+    def clear_config_name
+      @config_name = nil
+    end
+
     # (see Structure#buffer=)
     def buffer=(buffer)
       synchronize() do
@@ -306,7 +322,6 @@ module OpenC3
           Logger.instance.error "#{@target_name} #{@packet_name} received with actual packet length of #{buffer.length} but defined length of #{@defined_length}"
         end
         @read_conversion_cache.clear if @read_conversion_cache
-        process()
       end
     end
 
@@ -861,6 +876,33 @@ module OpenC3
       item.description = 'OpenC3 packet received count'
     end
 
+    # Reset the packet to just derived items
+    def clear_all_non_derived_items
+      @defined_length = 0
+      @defined_length_bits = 0
+      @pos_bit_size = 0
+      @neg_bit_size = 0
+      @fixed_size = true
+      @short_buffer_allowed = false
+      @id_items = nil
+      @limits_items = nil
+      new_items = {}
+      new_sorted_items = []
+      @items.each do |name, item|
+        if item.data_type == :DERIVED
+          new_items[name] = item
+        end
+      end
+      @sorted_items.each do |item|
+        if item.data_type == :DERIVED
+          new_sorted_items << item
+        end
+      end
+      @items = new_items
+      @sorted_items = new_sorted_items
+      clear_config_name()
+    end
+
     # Enable limits on an item by name
     #
     # @param name [String] Name of the item to enable limits
@@ -1008,6 +1050,13 @@ module OpenC3
       else
         config << "COMMAND #{@target_name.to_s.quote_if_necessary} #{@packet_name.to_s.quote_if_necessary} #{@default_endianness} \"#{@description}\"\n"
       end
+      if @accessor.class.to_s != 'OpenC3::BinaryAccessor'
+        config << "  ACCESSOR #{@accessor.class.to_s} #{@accessor.args.map { |a| a.to_s.quote_if_necessary }.join(" ")}\n"
+      end
+      # TODO: Add TEMPLATE_ENCODED so this can always be done inline regardless of content
+      if @template
+        config << "  TEMPLATE '#{@template}'"
+      end
       config << "  ALLOW_SHORT\n" if @short_buffer_allowed
       config << "  HAZARDOUS #{@hazardous_description.to_s.quote_if_necessary}\n" if @hazardous
       config << "  DISABLE_MESSAGES\n" if @messages_disabled
@@ -1025,7 +1074,7 @@ module OpenC3
 
       if @meta
         @meta.each do |key, values|
-          config << "  META #{key.to_s.quote_if_necessary} #{values.map { |a| a..to_s.quote_if_necessary }.join(" ")}\n"
+          config << "  META #{key.to_s.quote_if_necessary} #{values.map { |a| a.to_s.quote_if_necessary }.join(" ")}\n"
         end
       end
 
@@ -1043,6 +1092,20 @@ module OpenC3
         end
       end
 
+      if @response
+        config << "  RESPONSE #{@response[0].to_s.quote_if_necessary} #{@response[1].to_s.quote_if_necessary}"
+      end
+      if @error_response
+        config << "  ERROR_RESPONSE #{@error_response[0].to_s.quote_if_necessary} #{@error_response[1].to_s.quote_if_necessary}"
+      end
+      if @screen
+        config << "  SCREEN #{@screen[0].to_s.quote_if_necessary} #{@screen[1].to_s.quote_if_necessary}"
+      end
+      if @related_items
+        @related_items.each do |target_name, packet_name, item_name|
+          config << "  RELATED_ITEM #{target_name.to_s.quote_if_necessary} #{packet_name.to_s.quote_if_necessary} #{item_name.to_s.quote_if_necessary}"
+        end
+      end
       config
     end
 
@@ -1086,6 +1149,18 @@ module OpenC3
           items << item.as_json(*a)
         end
       end
+      if @response
+        config['response'] = @response
+      end
+      if @error_response
+        config['error_response'] = @error_response
+      end
+      if @screen
+        config['screen'] = @screen
+      end
+      if @related_items
+        config['related_items'] = @related_items
+      end
 
       config
     end
@@ -1117,6 +1192,19 @@ module OpenC3
       hash['items'].each do |item|
         packet.define(PacketItem.from_json(item))
       end
+      if hash['response']
+        packet.response = hash['response']
+      end
+      if hash['error_response']
+        packet.error_response = hash['error_response']
+      end
+      if hash['screen']
+        packet.screen = hash['screen']
+      end
+      if hash['related_items']
+        packet.related_items = hash['related_items']
+      end
+
       packet
     end
 
@@ -1144,8 +1232,6 @@ module OpenC3
       json_hash
     end
 
-    protected
-
     # Performs packet specific processing on the packet.
     # Intended to only be run once for each packet received
     def process(buffer = @buffer)
@@ -1156,6 +1242,8 @@ module OpenC3
       end
     end
 
+    protected
+
     def handle_limits_states(item, value)
       # Retrieve limits state for the given value
       limits_state = item.state_colors[value]

data/lib/openc3/packets/packet_config.rb

@@ -214,7 +214,8 @@ module OpenC3
               'PARAMETER', 'ID_ITEM', 'ID_PARAMETER', 'ARRAY_ITEM', 'ARRAY_PARAMETER', 'APPEND_ITEM',\
               'APPEND_PARAMETER', 'APPEND_ID_ITEM', 'APPEND_ID_PARAMETER', 'APPEND_ARRAY_ITEM',\
               'APPEND_ARRAY_PARAMETER', 'ALLOW_SHORT', 'HAZARDOUS', 'PROCESSOR', 'META',\
-              'DISABLE_MESSAGES', 'HIDDEN', 'DISABLED', 'ACCESSOR', 'TEMPLATE', 'TEMPLATE_FILE'
+              'DISABLE_MESSAGES', 'HIDDEN', 'DISABLED', 'ACCESSOR', 'TEMPLATE', 'TEMPLATE_FILE',\
+              'RESPONSE', 'ERROR_RESPONSE', 'SCREEN', 'RELATED_ITEM'
             raise parser.error("No current packet for #{keyword}") unless @current_packet
 
             process_current_packet(parser, keyword, params)
@@ -314,30 +315,60 @@ module OpenC3
           hash = @cmd_id_value_hash[@current_packet.target_name]
           hash = {} unless hash
           @cmd_id_value_hash[@current_packet.target_name] = hash
-          update_id_value_hash(hash)
+          update_id_value_hash(@current_packet, hash)
         else
           @telemetry[@current_packet.target_name][@current_packet.packet_name] = @current_packet
           hash = @tlm_id_value_hash[@current_packet.target_name]
           hash = {} unless hash
           @tlm_id_value_hash[@current_packet.target_name] = hash
-          update_id_value_hash(hash)
+          update_id_value_hash(@current_packet, hash)
         end
         @current_packet = nil
         @current_item = nil
       end
     end
 
+    def dynamic_add_packet(packet, cmd_or_tlm = :TELEMETRY, affect_ids: false)
+      if cmd_or_tlm == :COMMAND
+        @commands[packet.target_name][packet.packet_name] = packet
+
+        if affect_ids
+          hash = @cmd_id_value_hash[packet.target_name]
+          hash = {} unless hash
+          @cmd_id_value_hash[packet.target_name] = hash
+          update_id_value_hash(packet, hash)
+        end
+      else
+        @telemetry[packet.target_name][packet.packet_name] = packet
+
+        # Update latest_data lookup for telemetry
+        packet.sorted_items.each do |item|
+          target_latest_data = @latest_data[packet.target_name]
+          target_latest_data[item.name] ||= []
+          latest_data_packets = target_latest_data[item.name]
+          latest_data_packets << packet unless latest_data_packets.include?(packet)
+        end
+
+        if affect_ids
+          hash = @tlm_id_value_hash[packet.target_name]
+          hash = {} unless hash
+          @tlm_id_value_hash[packet.target_name] = hash
+          update_id_value_hash(packet, hash)
+        end
+      end
+    end
+
     protected
 
-    def update_id_value_hash(hash)
-      if @current_packet.id_items.length > 0
+    def update_id_value_hash(packet, hash)
+      if packet.id_items.length > 0
         key = []
-        @current_packet.id_items.each do |item|
+        packet.id_items.each do |item|
           key << item.id_value
         end
-        hash[key] = @current_packet
+        hash[key] = packet
       else
-        hash['CATCHALL'.freeze] = @current_packet
+        hash['CATCHALL'.freeze] = packet
       end
     end
 
@@ -460,7 +491,30 @@ module OpenC3
         rescue Exception => err
           raise parser.error(err)
         end
+
+      when 'RESPONSE'
+        usage = "#{keyword} <Target Name> <Packet Name>"
+        parser.verify_num_parameters(2, 2, usage)
+        @current_packet.response = [params[0].upcase, params[1].upcase]
+
+      when 'ERROR_RESPONSE'
+        usage = "#{keyword} <Target Name> <Packet Name>"
+        parser.verify_num_parameters(2, 2, usage)
+        @current_packet.error_response = [params[0].upcase, params[1].upcase]
+
+      when 'SCREEN'
+        usage = "#{keyword} <Target Name> <Screen Name>"
+        parser.verify_num_parameters(2, 2, usage)
+        @current_packet.screen = [params[0].upcase, params[1].upcase]
+
+      when 'RELATED_ITEM'
+        usage = "#{keyword} <Target Name> <Packet Name> <Item Name>"
+        parser.verify_num_parameters(3, 3, usage)
+        @current_packet.related_items ||= []
+        @current_packet.related_items << [params[0].upcase, params[1].upcase, params[2].upcase]
+
       end
+
     end
 
     def process_current_item(parser, keyword, params)

data/lib/openc3/packets/telemetry.rb

@@ -442,5 +442,9 @@ module OpenC3
     def all
       @config.telemetry
     end
+
+    def dynamic_add_packet(packet, affect_ids: false)
+      @config.dynamic_add_packet(packet, :TELEMETRY, affect_ids: affect_ids)
+    end
   end # class Telemetry
 end

data/lib/openc3/script/api_shared.rb

@@ -525,6 +525,17 @@ module OpenC3
     # Private implementation details
     ###########################################################################
 
+    # This must be here for custom microservices that might block.
+    # Overriden by running_script.rb for script sleep
+    def openc3_script_sleep(sleep_time = nil)
+      if sleep_time
+        sleep(sleep_time)
+      else
+        prompt("Press any key to continue...")
+      end
+      return false
+    end
+
     # Creates a string with the parameters upcased
     def _upcase(target_name, packet_name, item_name)
       "#{target_name.upcase} #{packet_name.upcase} #{item_name.upcase}"

data/lib/openc3/script/script.rb

@@ -93,17 +93,8 @@ module OpenC3
       $script_runner_api_server = nil
     end
 
-    # This isn't part of the public API because users should use wait()
-    def openc3_script_sleep(sleep_time = nil)
-      if sleep_time
-        sleep(sleep_time)
-      else
-        prompt("Press any key to continue...")
-      end
-      return false
-    end
-
     # Internal method used in scripts when encountering a hazardous command
+    # Not part of public APIs but must be implemented here
     def prompt_for_hazardous(target_name, cmd_name, hazardous_description)
       loop do
         message = "Warning: Command #{target_name} #{cmd_name} is Hazardous. "
@@ -140,6 +131,7 @@ module OpenC3
       default = ''
       if blank_or_default != true && blank_or_default != false
         question << " (default = #{blank_or_default})"
+        default = blank_or_default.to_s
         allow_blank = true
       else
         allow_blank = blank_or_default
@@ -150,7 +142,9 @@ module OpenC3
         answer.chomp!
         break if allow_blank
       end
-      answer = default if answer.empty? and !default.empty?
+      if answer.empty? and !default.empty?
+        answer = default
+      end
       return answer
     end
 
@@ -162,7 +156,7 @@ module OpenC3
 
     def message_box(string, *buttons, **options)
       print "#{string} (#{buttons.join(", ")}): "
-      print "Details: #{details}\n" if details
+      print "Details: #{details}\n" if options['details']
       gets.chomp
     end
 

data/lib/openc3/streams/tcpip_socket_stream.rb

@@ -160,5 +160,24 @@ module OpenC3
       @pipe_writer.write('.')
       @connected = false
     end
+
+    def set_option(option_name, option_values)
+      option_name_upcase = option_name.upcase
+
+      case option_name_upcase
+      when 'KEEPALIVE'
+        @write_socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
+        @read_socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
+      when 'KEEPCNT'
+        @write_socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPCNT, Integer(option_values[0]))
+        @read_socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPCNT, Integer(option_values[0]))
+      when 'KEEPIDLE'
+        @write_socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPIDLE, Integer(option_values[0]))
+        @read_socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPIDLE, Integer(option_values[0]))
+      when 'KEEPINTVL'
+        @write_socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPINTVL, Integer(option_values[0]))
+        @read_socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPINTVL, Integer(option_values[0]))
+      end
+    end
   end
 end