def return_all_queue_details(self):

        results             = build_dict("FAILED", "Not Found", { "Queues" : [] })

        try:

            if self.m_channel == None:
                results     = build_dict("FAILED", "Not Connected", { "Queues" : [] })
            else:
                    
                try:

                    proc        = subprocess.Popen("/usr/bin/rabbitmqadmin list queues name node durable auto_delete policy pid owner_pid exclusive_consumer_pid exclusive_consumer_tag messages_ready messages_unacknowledged messages messages_ready_ram messages_ram messages_persistent message_bytes consumers consumer_utilisation memory state save_nodes synchronised_slave_nodes arguments", shell=True, stdout=subprocess.PIPE)
                    std_rows    = proc.communicate()[0].split("\n")
                    results     = build_dict("SUCCESS", "Found Queues", {
                                                        "Queues"  : [],
                                                })


                    self.lg("Building Queues Rows(" + str(len(std_rows)) + ")", 6)
                    use_row     = False
                    cur_row     = 0
                    for row in std_rows:

                        if use_row:
                            row_arr         = row.split("|")

                            if len(row_arr) > 1:
                                self.dlg("Queue Row(" + str(row_arr) + ")", 6)
                                queue_name  = str(row_arr[1]).strip().lstrip()
                                node        = str(row_arr[2]).strip().lstrip()
                                durable     = str(row_arr[3]).strip().lstrip()
                                auto_delete = str(row_arr[4]).strip().lstrip()
                                policy      = str(row_arr[5]).strip().lstrip()
                                pid         = str(row_arr[6]).strip().lstrip()
                                owner_pid   = str(row_arr[7]).strip().lstrip()
                                exc_con_pid = str(row_arr[8]).strip().lstrip()
                                exc_con_tag = str(row_arr[9]).strip().lstrip()
                                msgs_ready  = str(row_arr[10]).strip().lstrip()
                                msgs_unack  = str(row_arr[11]).strip().lstrip()
                                messages    = str(row_arr[12]).strip().lstrip()
                                msg_rdy_ram = str(row_arr[13]).strip().lstrip()
                                msgs_ram    = str(row_arr[14]).strip().lstrip()
                                msgs_perst  = str(row_arr[15]).strip().lstrip()
                                msg_bytes   = str(row_arr[16]).strip().lstrip()
                                consumers   = str(row_arr[17]).strip().lstrip()
                                cons_util   = str(row_arr[18]).strip().lstrip()
                                memory      = str(row_arr[19]).strip().lstrip()
                                state       = str(row_arr[20]).strip().lstrip()
                                slave_nodes = str(row_arr[21]).strip().lstrip()
                                sync_slaves = str(row_arr[22]).strip().lstrip()
                                arguments   = str(row_arr[23]).strip().lstrip()
                                
                                new_queue   = {
                                                "Name"                  : str(queue_name),
                                                "Node"                  : str(node),
                                                "Durable"               : str(durable),
                                                "AutoDelete"            : str(auto_delete),
                                                "Policy"                : str(policy),
                                                "PID"                   : str(pid),
                                                "OwnerPID"              : str(owner_pid),
                                                "ExclusiveConsumerPID"  : str(exc_con_pid),
                                                "ExclusiveConsumerTag"  : str(exc_con_tag),
                                                "MsgsReady"             : str(msgs_ready),
                                                "MsgsUnacked"           : str(msgs_unack),
                                                "Msgs"                  : str(messages),
                                                "MsgsReadyRam"          : str(msg_rdy_ram),
                                                "MsgsRam"               : str(msgs_ram),
                                                "MsgsPersistent"        : str(msgs_perst),
                                                "MsgsBytes"             : str(msg_bytes),
                                                "Consumers"             : str(consumers),
                                                "ConsumerUtilization"   : str(cons_util),
                                                "Memory"                : str(memory),
                                                "State"                 : str(state),
                                                "SlaveNodes"            : str(slave_nodes),
                                                "SyncSlaveNodes"        : str(sync_slaves),
                                                "State"                 : str(state),
                                                "Arguments"             : str(arguments)
                                            }
                        
                                results["Record"]["Queues"].append(new_queue)
                        else:
                            if cur_row > 1:
                                use_row = True
                        # end of skip first headers
                        cur_row         += 1

                    # build all the queues

                except Exception,h:
                    self.lg("Get All Queues Failed with Ex(" + str(h) + ")", 6)
                    results     = build_dict("SUCCESS", "No Queues", { "Queues" : [] })
                # end of try/ex for getting the queue

        except Exception,k:
            err_msg             = "Failed to run return_all_queue_details with Ex(" + str(k) + ")"
            self.lg("ERROR: " + str(err_msg), 0)
            self.m_status       = "Failed"
            results             = build_dict("FAILED", str(err_msg), { "Queues" : [] })
        # end of try/ex

        return results
    # end of return_all_queue_details
Find the app named *module_name*, instantiate it, and add it to
dataset/ETHPy150Open GetLevvel/message-simulator/src/rabbit_message_publisher.py/RabbitMessagePublisher.return_all_queue_details--crossover with--dataset/ETHPy150Open rapidsms/rapidsms-core-dev/lib/rapidsms/router.py/Router.add_app