def start_consumers(self):

        # Future enhancements should wait for all queues to be created before creating Consumer processes

        if len(self.m_consumer_config) > 0:

            self.lg("Starting Consumers for Queues(" + str(len(self.m_consumer_config["ConsumeQueues"])) + ")", 6)
            self.m_consumers        = []

            self.m_con_prefix_name  = str(self.m_consumer_config["PrefixName"]).lstrip().strip()
            self.m_con_pid_dir      = str(self.m_consumer_config["PIDDir"]).lstrip().strip()
            self.m_con_tmp_dir      = str(self.m_consumer_config["TmpConfigDir"]).lstrip().strip()

            self.m_consume_queues   = self.m_consumer_config["ConsumeQueues"]
            consumer_count          = 0

            for consume_node in self.m_consume_queues:

                self.m_num_consumers    = int(consume_node["NumConsumers"])
                self.m_con_script       = str(consume_node["Starter"]).lstrip().strip()
                self.m_con_interval     = float(consume_node["ConsumeInt"])
                consumer_queue          = str(consume_node["Queue"])

                if os.path.exists(self.m_con_script) == False:
                    dirname, filename         = os.path.split(os.path.abspath(__file__))
                    test_in_relative_src_dir  = dirname + "/../" + str(self.m_con_script)
                    if os.path.exists(test_in_relative_src_dir):
                        self.lg("Overriding Consumer Starter Script to Path(" + str(test_in_relative_src_dir) + ")", 6)
                        self.m_con_script     = test_in_relative_src_dir
                    else:
                        # Make sure to print this in Red stdout to help debug install issues
                        self.elg("Failed to Find Consumer Executable at Relative Path(" + str(self.m_con_script) + ") or Absolute Path(" % str(test_in_relative_src_dir) + ") Please confirm one of these paths exists for using a consumer", True)
                        self.elg("Failed to Find Consumer Executable at Relative Path(" + str(self.m_con_script) + ") or Absolute Path(" + str(test_in_relative_src_dir) + ") Please confirm one of these paths exists for using a consumer", True)
                        self.elg("Failed to Find Consumer Executable at Relative Path(" + str(self.m_con_script) + ") or Absolute Path(" + str(test_in_relative_src_dir) + ") Please confirm one of these paths exists for using a consumer", True)
                # end of checking that the running instance could be outside of the message-simulator repo

                self.lg("Creating Consumer Proceses(" + str(self.m_num_consumers) + ")", 6)

                consumer_count          = 0
                while consumer_count < self.m_num_consumers:
                    new_consumer        = {
                                                "Name"              : self.m_con_prefix_name + str(consumer_count),
                                                "ConsumerTag"       : self.m_con_prefix_name + str(consumer_count) + "_" + str(build_unique_key()),
                                                "Starter"           : str(self.m_con_script),
                                                "Config"            : "",
                                                "Queue"             : str(consume_node["Queue"]),
                                                "Interval"          : float(consume_node["ConsumeInt"]),
                                                "CheckDone"         : float(consume_node["CheckDone"]),
                                                "PIDDir"            : str(self.m_con_pid_dir),
                                                "PID"               : "",
                                                "ProcessObj"        : "",
                                                "Command"           : "",
                                                "TmpConfigDir"      : str(self.m_con_tmp_dir),
                                                "NumberMessages"    : int(consume_node["NumberMessages"]),
                                                "ReplyToQueue"      : str(consume_node["ReplyToQueue"]),
                                                "ValidateBody"      : bool(consume_node["ValidateBody"]),
                                                "Expected"          : consume_node["Expected"],
                                                "Debug"             : False
                                        }

                    new_config_path             = self.write_consumer_config_to_disk(new_consumer)

                    # Start the consumer
                    consumer_command            = self.m_con_script + " -f " + new_config_path + " >> /dev/null"
                    if self.m_debug:
                        self.lg("Starting Consumer with Command(" + str(consumer_command) + ")", 6)

                    proc                        = subprocess.Popen(consumer_command, shell=True, stdout=subprocess.PIPE)

                    new_consumer["PID"]         = int(proc.pid)
                    new_consumer["ProcessObj"]  = proc
                    new_consumer["Command"]     = consumer_command

                    self.m_consumers.append(new_consumer)

                    consumer_count      += 1    
                # end of building out consumers
            # for all consumer queues to monitor
        # if there are consumers for this simulation

    # end of start_consumers
dataset/ETHPy150Open GetLevvel/message-simulator/src/rabbit_message_publisher.py/RabbitMessagePublisher.start_consumers/operator `+` -> `%`