Source: hipercontracer
Section: net
Priority: optional
Maintainer: Thomas Dreibholz <dreibh@simula.no>
Homepage: https://www.nntb.no/~dreibh/hipercontracer/
Vcs-Git: https://github.com/dreibh/hipercontracer.git
Vcs-Browser: https://github.com/dreibh/hipercontracer
Build-Depends: cmake (>= 3.10),
               debhelper (>= 12),
               ghostscript,
               graphicsmagick,
               libboost-date-time-dev,
               libboost-filesystem-dev,
               libboost-iostreams-dev,
               libboost-log-dev,
               libboost-program-options-dev,
               libboost-system-dev,
               libboost-thread-dev,
               libbz2-dev,
               liblzma-dev,
               libmariadb-dev,
               libmongoc-dev,
               libpqxx-dev,
               libzstd-dev,
               pdf2svg,
               zlib1g-dev
Standards-Version: 4.7.2
Rules-Requires-Root: no

Package: hipercontracer
Architecture: any
Depends: hipercontracer-common,
         iproute2,
         libhipercontracer2 (= ${binary:Version}),
         ${misc:Depends},
         ${shlibs:Depends}
Recommends: ethtool,
            hipercontracer-viewer
Suggests: hipercontracer-collector,
          hipercontracer-dbeaver-tools,
          hipercontracer-dbshell,
          hipercontracer-importer,
          hipercontracer-node,
          hipercontracer-query,
          hipercontracer-results,
          hipercontracer-sync,
          hipercontracer-trigger,
          hipercontracer-udp-echo-server,
          netperfmeter,
          td-system-info
Description: High-Performance Connectivity Tracer (HiPerConTracer)
 High-Performance Connectivity Tracer (HiPerConTracer) is a Ping/Traceroute
 measurement framework. HiPerConTracer denotes the actual measurement
 tool. It performs regular Ping and Traceroute runs among sites, featuring:
 multi-transport-protocol support (ICMP, UDP); multi-homing and parallelism
 support; handling of load balancing in the network; multi-platform
 support (currently Linux and FreeBSD); high-precision (nanoseconds)
 timing support (Linux timestamping, both software and hardware); a
 library (shared/static) to integrate measurement functionality into other
 software (libhipercontracer); open source and written in a performance-
 and portability-focused programming language (C++) with only limited
 dependencies.
 .
 Furthermore, the HiPerConTracer Framework furthermore provides additional
 tools for helping to obtain, process, collect, store, and retrieve
 measurement data: HiPerConTracer Viewer Tool for displaying the contents
 of results files; Results Tool for merging and converting results files,
 e.g. to create a Comma-Separated Value (CSV) file; Sync Tool for copying data
 from a measurement node (vantage point) to a remote HiPerConTracer Collector
 server (via RSync/SSH); Reverse Tunnel Tool for maintaining a reverse SSH
 tunnel from a remote measurement node to a HiPerConTracer Collector server;
 Collector/Node Tools for simplifying the setup of HiPerConTracer Nodes and a
 HiPerConTracer Collector server; Trigger Tool for triggering HiPerConTracer
 measurements in the reverse direction; Importer Tool for storing measurement
 data from results files into SQL or NoSQL databases. Currently, database
 backends for MariaDB/MySQL PostgreSQL, MongoDB) are provided; Query
 Tool for querying data from a database and storing it into a results
 file; Database Shell as simple command-line front-end for the underlying
 database backends; Database Tools with some helper scripts to e.g. to join
 HiPerConTracer database configurations into an existing DBeaver (a popular
 SQL database GUI application) configuration; UDP Echo Server as UDP Echo
 (RFC 862) protocol endpoint; Wireshark dissector for HiPerConTracer packets.
 .
 This package contains the actual HiPerConTracer program.

Package: hipercontracer-common
Architecture: all
Depends: acl,
         passwd,
         ${misc:Depends}
Suggests: python3,
          r-base-core
Description: HiPerConTracer common files
 High-Performance Connectivity Tracer (HiPerConTracer) is a Ping/Traceroute
 measurement framework. HiPerConTracer denotes the actual measurement
 tool. It performs regular Ping and Traceroute runs among sites, featuring:
 multi-transport-protocol support (ICMP, UDP); multi-homing and parallelism
 support; handling of load balancing in the network; multi-platform
 support (currently Linux and FreeBSD); high-precision (nanoseconds)
 timing support (Linux timestamping, both software and hardware); a
 library (shared/static) to integrate measurement functionality into other
 software (libhipercontracer); open source and written in a performance-
 and portability-focused programming language (C++) with only limited
 dependencies.
 .
 Furthermore, the HiPerConTracer Framework furthermore provides additional
 tools for helping to obtain, process, collect, store, and retrieve
 measurement data: HiPerConTracer Viewer Tool for displaying the contents
 of results files; Results Tool for merging and converting results files,
 e.g. to create a Comma-Separated Value (CSV) file; Sync Tool for copying data
 from a measurement node (vantage point) to a remote HiPerConTracer Collector
 server (via RSync/SSH); Reverse Tunnel Tool for maintaining a reverse SSH
 tunnel from a remote measurement node to a HiPerConTracer Collector server;
 Collector/Node Tools for simplifying the setup of HiPerConTracer Nodes and a
 HiPerConTracer Collector server; Trigger Tool for triggering HiPerConTracer
 measurements in the reverse direction; Importer Tool for storing measurement
 data from results files into SQL or NoSQL databases. Currently, database
 backends for MariaDB/MySQL PostgreSQL, MongoDB) are provided; Query
 Tool for querying data from a database and storing it into a results
 file; Database Shell as simple command-line front-end for the underlying
 database backends; Database Tools with some helper scripts to e.g. to join
 HiPerConTracer database configurations into an existing DBeaver (a popular
 SQL database GUI application) configuration; UDP Echo Server as UDP Echo
 (RFC 862) protocol endpoint; Wireshark dissector for HiPerConTracer packets.
 .
 The package contains common files for HiPerConTracer and the HiPerConTracer
 Tools packages.

Package: libhpctio2
Section: libs
Architecture: any
Depends: ${misc:Depends},
         ${shlibs:Depends}
Description: I/O library of HiPerConTracer
 High-Performance Connectivity Tracer (HiPerConTracer) is a Ping/Traceroute
 measurement framework. HiPerConTracer denotes the actual measurement
 tool. It performs regular Ping and Traceroute runs among sites, featuring:
 multi-transport-protocol support (ICMP, UDP); multi-homing and parallelism
 support; handling of load balancing in the network; multi-platform
 support (currently Linux and FreeBSD); high-precision (nanoseconds)
 timing support (Linux timestamping, both software and hardware); a
 library (shared/static) to integrate measurement functionality into other
 software (libhipercontracer); open source and written in a performance-
 and portability-focused programming language (C++) with only limited
 dependencies.
 .
 Furthermore, the HiPerConTracer Framework furthermore provides additional
 tools for helping to obtain, process, collect, store, and retrieve
 measurement data: HiPerConTracer Viewer Tool for displaying the contents
 of results files; Results Tool for merging and converting results files,
 e.g. to create a Comma-Separated Value (CSV) file; Sync Tool for copying data
 from a measurement node (vantage point) to a remote HiPerConTracer Collector
 server (via RSync/SSH); Reverse Tunnel Tool for maintaining a reverse SSH
 tunnel from a remote measurement node to a HiPerConTracer Collector server;
 Collector/Node Tools for simplifying the setup of HiPerConTracer Nodes and a
 HiPerConTracer Collector server; Trigger Tool for triggering HiPerConTracer
 measurements in the reverse direction; Importer Tool for storing measurement
 data from results files into SQL or NoSQL databases. Currently, database
 backends for MariaDB/MySQL PostgreSQL, MongoDB) are provided; Query
 Tool for querying data from a database and storing it into a results
 file; Database Shell as simple command-line front-end for the underlying
 database backends; Database Tools with some helper scripts to e.g. to join
 HiPerConTracer database configurations into an existing DBeaver (a popular
 SQL database GUI application) configuration; UDP Echo Server as UDP Echo
 (RFC 862) protocol endpoint; Wireshark dissector for HiPerConTracer packets.
 .
 This library shares I/O functions commonly used by libhipercontracer and
 libuniversalimporter.

Package: libhpctio-dev
Section: libdevel
Architecture: any
Breaks: libhipercontracer-dev (<< ${source:Version}),
        libuniversalimporter-dev (<< ${source:Version})
Depends: libboost-date-time-dev,
         libboost-filesystem-dev,
         libboost-iostreams-dev,
         libboost-log-dev,
         libboost-system-dev,
         libboost-thread-dev,
         libhpctio2 (= ${binary:Version}),
         ${misc:Depends}
Description: Development files for the HiPerConTracer I/O library
 High-Performance Connectivity Tracer (HiPerConTracer) is a Ping/Traceroute
 measurement framework. HiPerConTracer denotes the actual measurement
 tool. It performs regular Ping and Traceroute runs among sites, featuring:
 multi-transport-protocol support (ICMP, UDP); multi-homing and parallelism
 support; handling of load balancing in the network; multi-platform
 support (currently Linux and FreeBSD); high-precision (nanoseconds)
 timing support (Linux timestamping, both software and hardware); a
 library (shared/static) to integrate measurement functionality into other
 software (libhipercontracer); open source and written in a performance-
 and portability-focused programming language (C++) with only limited
 dependencies.
 .
 Furthermore, the HiPerConTracer Framework furthermore provides additional
 tools for helping to obtain, process, collect, store, and retrieve
 measurement data: HiPerConTracer Viewer Tool for displaying the contents
 of results files; Results Tool for merging and converting results files,
 e.g. to create a Comma-Separated Value (CSV) file; Sync Tool for copying data
 from a measurement node (vantage point) to a remote HiPerConTracer Collector
 server (via RSync/SSH); Reverse Tunnel Tool for maintaining a reverse SSH
 tunnel from a remote measurement node to a HiPerConTracer Collector server;
 Collector/Node Tools for simplifying the setup of HiPerConTracer Nodes and a
 HiPerConTracer Collector server; Trigger Tool for triggering HiPerConTracer
 measurements in the reverse direction; Importer Tool for storing measurement
 data from results files into SQL or NoSQL databases. Currently, database
 backends for MariaDB/MySQL PostgreSQL, MongoDB) are provided; Query
 Tool for querying data from a database and storing it into a results
 file; Database Shell as simple command-line front-end for the underlying
 database backends; Database Tools with some helper scripts to e.g. to join
 HiPerConTracer database configurations into an existing DBeaver (a popular
 SQL database GUI application) configuration; UDP Echo Server as UDP Echo
 (RFC 862) protocol endpoint; Wireshark dissector for HiPerConTracer packets.
 .
 This package provides header files for the HiPerConTracer I/O library.

Package: libhipercontracer2
Section: libs
Architecture: any
Depends: libhpctio2 (= ${binary:Version}),
         ${misc:Depends},
         ${shlibs:Depends}
Description: API library of HiPerConTracer
 High-Performance Connectivity Tracer (HiPerConTracer) is a Ping/Traceroute
 measurement framework. HiPerConTracer denotes the actual measurement
 tool. It performs regular Ping and Traceroute runs among sites, featuring:
 multi-transport-protocol support (ICMP, UDP); multi-homing and parallelism
 support; handling of load balancing in the network; multi-platform
 support (currently Linux and FreeBSD); high-precision (nanoseconds)
 timing support (Linux timestamping, both software and hardware); a
 library (shared/static) to integrate measurement functionality into other
 software (libhipercontracer); open source and written in a performance-
 and portability-focused programming language (C++) with only limited
 dependencies.
 .
 Furthermore, the HiPerConTracer Framework furthermore provides additional
 tools for helping to obtain, process, collect, store, and retrieve
 measurement data: HiPerConTracer Viewer Tool for displaying the contents
 of results files; Results Tool for merging and converting results files,
 e.g. to create a Comma-Separated Value (CSV) file; Sync Tool for copying data
 from a measurement node (vantage point) to a remote HiPerConTracer Collector
 server (via RSync/SSH); Reverse Tunnel Tool for maintaining a reverse SSH
 tunnel from a remote measurement node to a HiPerConTracer Collector server;
 Collector/Node Tools for simplifying the setup of HiPerConTracer Nodes and a
 HiPerConTracer Collector server; Trigger Tool for triggering HiPerConTracer
 measurements in the reverse direction; Importer Tool for storing measurement
 data from results files into SQL or NoSQL databases. Currently, database
 backends for MariaDB/MySQL PostgreSQL, MongoDB) are provided; Query
 Tool for querying data from a database and storing it into a results
 file; Database Shell as simple command-line front-end for the underlying
 database backends; Database Tools with some helper scripts to e.g. to join
 HiPerConTracer database configurations into an existing DBeaver (a popular
 SQL database GUI application) configuration; UDP Echo Server as UDP Echo
 (RFC 862) protocol endpoint; Wireshark dissector for HiPerConTracer packets.
 .
 The HiPerConTracer library is provided by this package.

Package: libhipercontracer-dev
Section: libdevel
Architecture: any
Depends: libboost-date-time-dev,
         libboost-filesystem-dev,
         libboost-iostreams-dev,
         libboost-log-dev,
         libboost-system-dev,
         libboost-thread-dev,
         libhipercontracer2 (= ${binary:Version}),
         libhpctio-dev (>= ${source:Version}),
         ${misc:Depends}
Description: Development files for HiPerConTracer API library
 High-Performance Connectivity Tracer (HiPerConTracer) is a Ping/Traceroute
 measurement framework. HiPerConTracer denotes the actual measurement
 tool. It performs regular Ping and Traceroute runs among sites, featuring:
 multi-transport-protocol support (ICMP, UDP); multi-homing and parallelism
 support; handling of load balancing in the network; multi-platform
 support (currently Linux and FreeBSD); high-precision (nanoseconds)
 timing support (Linux timestamping, both software and hardware); a
 library (shared/static) to integrate measurement functionality into other
 software (libhipercontracer); open source and written in a performance-
 and portability-focused programming language (C++) with only limited
 dependencies.
 .
 Furthermore, the HiPerConTracer Framework furthermore provides additional
 tools for helping to obtain, process, collect, store, and retrieve
 measurement data: HiPerConTracer Viewer Tool for displaying the contents
 of results files; Results Tool for merging and converting results files,
 e.g. to create a Comma-Separated Value (CSV) file; Sync Tool for copying data
 from a measurement node (vantage point) to a remote HiPerConTracer Collector
 server (via RSync/SSH); Reverse Tunnel Tool for maintaining a reverse SSH
 tunnel from a remote measurement node to a HiPerConTracer Collector server;
 Collector/Node Tools for simplifying the setup of HiPerConTracer Nodes and a
 HiPerConTracer Collector server; Trigger Tool for triggering HiPerConTracer
 measurements in the reverse direction; Importer Tool for storing measurement
 data from results files into SQL or NoSQL databases. Currently, database
 backends for MariaDB/MySQL PostgreSQL, MongoDB) are provided; Query
 Tool for querying data from a database and storing it into a results
 file; Database Shell as simple command-line front-end for the underlying
 database backends; Database Tools with some helper scripts to e.g. to join
 HiPerConTracer database configurations into an existing DBeaver (a popular
 SQL database GUI application) configuration; UDP Echo Server as UDP Echo
 (RFC 862) protocol endpoint; Wireshark dissector for HiPerConTracer packets.
 .
 This package provides header files for the HiPerConTracer library. You need
 them to integrate HiPerConTracer into own programs.

Package: libuniversalimporter2
Section: libs
Architecture: any
Depends: libhpctio2 (= ${binary:Version}),
         ${misc:Depends},
         ${shlibs:Depends}
Description: API library of HiPerConTracer Universal Importer
 High-Performance Connectivity Tracer (HiPerConTracer) is a Ping/Traceroute
 measurement framework. HiPerConTracer denotes the actual measurement
 tool. It performs regular Ping and Traceroute runs among sites, featuring:
 multi-transport-protocol support (ICMP, UDP); multi-homing and parallelism
 support; handling of load balancing in the network; multi-platform
 support (currently Linux and FreeBSD); high-precision (nanoseconds)
 timing support (Linux timestamping, both software and hardware); a
 library (shared/static) to integrate measurement functionality into other
 software (libhipercontracer); open source and written in a performance-
 and portability-focused programming language (C++) with only limited
 dependencies.
 .
 Furthermore, the HiPerConTracer Framework furthermore provides additional
 tools for helping to obtain, process, collect, store, and retrieve
 measurement data: HiPerConTracer Viewer Tool for displaying the contents
 of results files; Results Tool for merging and converting results files,
 e.g. to create a Comma-Separated Value (CSV) file; Sync Tool for copying data
 from a measurement node (vantage point) to a remote HiPerConTracer Collector
 server (via RSync/SSH); Reverse Tunnel Tool for maintaining a reverse SSH
 tunnel from a remote measurement node to a HiPerConTracer Collector server;
 Collector/Node Tools for simplifying the setup of HiPerConTracer Nodes and a
 HiPerConTracer Collector server; Trigger Tool for triggering HiPerConTracer
 measurements in the reverse direction; Importer Tool for storing measurement
 data from results files into SQL or NoSQL databases. Currently, database
 backends for MariaDB/MySQL PostgreSQL, MongoDB) are provided; Query
 Tool for querying data from a database and storing it into a results
 file; Database Shell as simple command-line front-end for the underlying
 database backends; Database Tools with some helper scripts to e.g. to join
 HiPerConTracer database configurations into an existing DBeaver (a popular
 SQL database GUI application) configuration; UDP Echo Server as UDP Echo
 (RFC 862) protocol endpoint; Wireshark dissector for HiPerConTracer packets.
 .
 The HiPerConTracer Universal Importer library is provided by this
 package.

Package: libuniversalimporter-dev
Section: libdevel
Architecture: any
Depends: libboost-date-time-dev,
         libboost-filesystem-dev,
         libboost-iostreams-dev,
         libboost-log-dev,
         libboost-system-dev,
         libboost-thread-dev,
         libhpctio-dev (>= ${source:Version}),
         libuniversalimporter2 (= ${binary:Version}),
         ${misc:Depends}
Description: Development files for HiPerConTracer Universal Importer API library
 High-Performance Connectivity Tracer (HiPerConTracer) is a Ping/Traceroute
 measurement framework. HiPerConTracer denotes the actual measurement
 tool. It performs regular Ping and Traceroute runs among sites, featuring:
 multi-transport-protocol support (ICMP, UDP); multi-homing and parallelism
 support; handling of load balancing in the network; multi-platform
 support (currently Linux and FreeBSD); high-precision (nanoseconds)
 timing support (Linux timestamping, both software and hardware); a
 library (shared/static) to integrate measurement functionality into other
 software (libhipercontracer); open source and written in a performance-
 and portability-focused programming language (C++) with only limited
 dependencies.
 .
 Furthermore, the HiPerConTracer Framework furthermore provides additional
 tools for helping to obtain, process, collect, store, and retrieve
 measurement data: HiPerConTracer Viewer Tool for displaying the contents
 of results files; Results Tool for merging and converting results files,
 e.g. to create a Comma-Separated Value (CSV) file; Sync Tool for copying data
 from a measurement node (vantage point) to a remote HiPerConTracer Collector
 server (via RSync/SSH); Reverse Tunnel Tool for maintaining a reverse SSH
 tunnel from a remote measurement node to a HiPerConTracer Collector server;
 Collector/Node Tools for simplifying the setup of HiPerConTracer Nodes and a
 HiPerConTracer Collector server; Trigger Tool for triggering HiPerConTracer
 measurements in the reverse direction; Importer Tool for storing measurement
 data from results files into SQL or NoSQL databases. Currently, database
 backends for MariaDB/MySQL PostgreSQL, MongoDB) are provided; Query
 Tool for querying data from a database and storing it into a results
 file; Database Shell as simple command-line front-end for the underlying
 database backends; Database Tools with some helper scripts to e.g. to join
 HiPerConTracer database configurations into an existing DBeaver (a popular
 SQL database GUI application) configuration; UDP Echo Server as UDP Echo
 (RFC 862) protocol endpoint; Wireshark dissector for HiPerConTracer packets.
 .
 This package provides header files for the HiPerConTracer Universal Importer
 library. You need them to integrate HiPerConTracer Universal Importer into
 own programs.

Package: hipercontracer-trigger
Architecture: any
Depends: hipercontracer-common,
         libhipercontracer2 (= ${binary:Version}),
         ${misc:Depends},
         ${shlibs:Depends}
Recommends: hipercontracer
Description: Triggered HiPerConTracer service
 High-Performance Connectivity Tracer (HiPerConTracer) is a Ping/Traceroute
 measurement framework. HiPerConTracer denotes the actual measurement
 tool. It performs regular Ping and Traceroute runs among sites, featuring:
 multi-transport-protocol support (ICMP, UDP); multi-homing and parallelism
 support; handling of load balancing in the network; multi-platform
 support (currently Linux and FreeBSD); high-precision (nanoseconds)
 timing support (Linux timestamping, both software and hardware); a
 library (shared/static) to integrate measurement functionality into other
 software (libhipercontracer); open source and written in a performance-
 and portability-focused programming language (C++) with only limited
 dependencies.
 .
 Furthermore, the HiPerConTracer Framework furthermore provides additional
 tools for helping to obtain, process, collect, store, and retrieve
 measurement data: HiPerConTracer Viewer Tool for displaying the contents
 of results files; Results Tool for merging and converting results files,
 e.g. to create a Comma-Separated Value (CSV) file; Sync Tool for copying data
 from a measurement node (vantage point) to a remote HiPerConTracer Collector
 server (via RSync/SSH); Reverse Tunnel Tool for maintaining a reverse SSH
 tunnel from a remote measurement node to a HiPerConTracer Collector server;
 Collector/Node Tools for simplifying the setup of HiPerConTracer Nodes and a
 HiPerConTracer Collector server; Trigger Tool for triggering HiPerConTracer
 measurements in the reverse direction; Importer Tool for storing measurement
 data from results files into SQL or NoSQL databases. Currently, database
 backends for MariaDB/MySQL PostgreSQL, MongoDB) are provided; Query
 Tool for querying data from a database and storing it into a results
 file; Database Shell as simple command-line front-end for the underlying
 database backends; Database Tools with some helper scripts to e.g. to join
 HiPerConTracer database configurations into an existing DBeaver (a popular
 SQL database GUI application) configuration; UDP Echo Server as UDP Echo
 (RFC 862) protocol endpoint; Wireshark dissector for HiPerConTracer packets.
 .
 This tool triggers HiPerConTracer measurements by incoming "Ping" packets.

Package: hipercontracer-sync
Architecture: all
Provides: hipercontracer-sync-tool
Replaces: hipercontracer-sync-tool
Breaks: hipercontracer-sync-tool (<< ${source:Version})
Depends: hipercontracer-common,
         openssh-client,
         rsync,
         ${misc:Depends}
Recommends: hipercontracer,
            hipercontracer-results
Description: HiPerConTracer Sync Tool to synchronise results files to a server
 High-Performance Connectivity Tracer (HiPerConTracer) is a Ping/Traceroute
 measurement framework. HiPerConTracer denotes the actual measurement
 tool. It performs regular Ping and Traceroute runs among sites, featuring:
 multi-transport-protocol support (ICMP, UDP); multi-homing and parallelism
 support; handling of load balancing in the network; multi-platform
 support (currently Linux and FreeBSD); high-precision (nanoseconds)
 timing support (Linux timestamping, both software and hardware); a
 library (shared/static) to integrate measurement functionality into other
 software (libhipercontracer); open source and written in a performance-
 and portability-focused programming language (C++) with only limited
 dependencies.
 .
 Furthermore, the HiPerConTracer Framework furthermore provides additional
 tools for helping to obtain, process, collect, store, and retrieve
 measurement data: HiPerConTracer Viewer Tool for displaying the contents
 of results files; Results Tool for merging and converting results files,
 e.g. to create a Comma-Separated Value (CSV) file; Sync Tool for copying data
 from a measurement node (vantage point) to a remote HiPerConTracer Collector
 server (via RSync/SSH); Reverse Tunnel Tool for maintaining a reverse SSH
 tunnel from a remote measurement node to a HiPerConTracer Collector server;
 Collector/Node Tools for simplifying the setup of HiPerConTracer Nodes and a
 HiPerConTracer Collector server; Trigger Tool for triggering HiPerConTracer
 measurements in the reverse direction; Importer Tool for storing measurement
 data from results files into SQL or NoSQL databases. Currently, database
 backends for MariaDB/MySQL PostgreSQL, MongoDB) are provided; Query
 Tool for querying data from a database and storing it into a results
 file; Database Shell as simple command-line front-end for the underlying
 database backends; Database Tools with some helper scripts to e.g. to join
 HiPerConTracer database configurations into an existing DBeaver (a popular
 SQL database GUI application) configuration; UDP Echo Server as UDP Echo
 (RFC 862) protocol endpoint; Wireshark dissector for HiPerConTracer packets.
 .
 This package contains the HiPerConTracer Sync Tool for running RSync
 synchronisation of data to a central HiPerConTracer Collector server.

Package: hipercontracer-rtunnel
Architecture: all
Depends: hipercontracer-common,
         hipercontracer-sync,
         openssh-server,
         ${misc:Depends}
Description: HiPerConTracer Reverse Tunnel Tool for reverse SSH tunnel setup
 High-Performance Connectivity Tracer (HiPerConTracer) is a Ping/Traceroute
 measurement framework. HiPerConTracer denotes the actual measurement
 tool. It performs regular Ping and Traceroute runs among sites, featuring:
 multi-transport-protocol support (ICMP, UDP); multi-homing and parallelism
 support; handling of load balancing in the network; multi-platform
 support (currently Linux and FreeBSD); high-precision (nanoseconds)
 timing support (Linux timestamping, both software and hardware); a
 library (shared/static) to integrate measurement functionality into other
 software (libhipercontracer); open source and written in a performance-
 and portability-focused programming language (C++) with only limited
 dependencies.
 .
 Furthermore, the HiPerConTracer Framework furthermore provides additional
 tools for helping to obtain, process, collect, store, and retrieve
 measurement data: HiPerConTracer Viewer Tool for displaying the contents
 of results files; Results Tool for merging and converting results files,
 e.g. to create a Comma-Separated Value (CSV) file; Sync Tool for copying data
 from a measurement node (vantage point) to a remote HiPerConTracer Collector
 server (via RSync/SSH); Reverse Tunnel Tool for maintaining a reverse SSH
 tunnel from a remote measurement node to a HiPerConTracer Collector server;
 Collector/Node Tools for simplifying the setup of HiPerConTracer Nodes and a
 HiPerConTracer Collector server; Trigger Tool for triggering HiPerConTracer
 measurements in the reverse direction; Importer Tool for storing measurement
 data from results files into SQL or NoSQL databases. Currently, database
 backends for MariaDB/MySQL PostgreSQL, MongoDB) are provided; Query
 Tool for querying data from a database and storing it into a results
 file; Database Shell as simple command-line front-end for the underlying
 database backends; Database Tools with some helper scripts to e.g. to join
 HiPerConTracer database configurations into an existing DBeaver (a popular
 SQL database GUI application) configuration; UDP Echo Server as UDP Echo
 (RFC 862) protocol endpoint; Wireshark dissector for HiPerConTracer packets.
 .
 This is the HiPerConTracer Reverse Tunnel Tool. It maintains an SSH
 reverse tunnel from a measurement node to a HiPerConTracer Collector server.

Package: hipercontracer-node
Architecture: all
Depends: hipercontracer,
         hipercontracer-rtunnel,
         hipercontracer-sync,
         sudo,
         ${misc:Depends}
Recommends: td-system-info,
            td-system-maintenance,
            unattended-upgrades
Description: HiPerConTracer Node Tools for maintaining a measurement node
 High-Performance Connectivity Tracer (HiPerConTracer) is a Ping/Traceroute
 measurement framework. HiPerConTracer denotes the actual measurement
 tool. It performs regular Ping and Traceroute runs among sites, featuring:
 multi-transport-protocol support (ICMP, UDP); multi-homing and parallelism
 support; handling of load balancing in the network; multi-platform
 support (currently Linux and FreeBSD); high-precision (nanoseconds)
 timing support (Linux timestamping, both software and hardware); a
 library (shared/static) to integrate measurement functionality into other
 software (libhipercontracer); open source and written in a performance-
 and portability-focused programming language (C++) with only limited
 dependencies.
 .
 Furthermore, the HiPerConTracer Framework furthermore provides additional
 tools for helping to obtain, process, collect, store, and retrieve
 measurement data: HiPerConTracer Viewer Tool for displaying the contents
 of results files; Results Tool for merging and converting results files,
 e.g. to create a Comma-Separated Value (CSV) file; Sync Tool for copying data
 from a measurement node (vantage point) to a remote HiPerConTracer Collector
 server (via RSync/SSH); Reverse Tunnel Tool for maintaining a reverse SSH
 tunnel from a remote measurement node to a HiPerConTracer Collector server;
 Collector/Node Tools for simplifying the setup of HiPerConTracer Nodes and a
 HiPerConTracer Collector server; Trigger Tool for triggering HiPerConTracer
 measurements in the reverse direction; Importer Tool for storing measurement
 data from results files into SQL or NoSQL databases. Currently, database
 backends for MariaDB/MySQL PostgreSQL, MongoDB) are provided; Query
 Tool for querying data from a database and storing it into a results
 file; Database Shell as simple command-line front-end for the underlying
 database backends; Database Tools with some helper scripts to e.g. to join
 HiPerConTracer database configurations into an existing DBeaver (a popular
 SQL database GUI application) configuration; UDP Echo Server as UDP Echo
 (RFC 862) protocol endpoint; Wireshark dissector for HiPerConTracer packets.
 .
 This is the HiPerConTracer Node package. It contains helper scripts to attach a
 HiPerConTracer Node to a HiPerConTracer Collector server.

Package: hipercontracer-collector
Architecture: all
Depends: hipercontracer-common,
         iproute2,
         openssh-client,
         openssh-server,
         rsync,
         sudo,
         ${misc:Depends}
Recommends: td-system-info,
            td-system-maintenance,
            unattended-upgrades
Description: HiPerConTracer Collector Tools for collecting measurement results
 High-Performance Connectivity Tracer (HiPerConTracer) is a Ping/Traceroute
 measurement framework. HiPerConTracer denotes the actual measurement
 tool. It performs regular Ping and Traceroute runs among sites, featuring:
 multi-transport-protocol support (ICMP, UDP); multi-homing and parallelism
 support; handling of load balancing in the network; multi-platform
 support (currently Linux and FreeBSD); high-precision (nanoseconds)
 timing support (Linux timestamping, both software and hardware); a
 library (shared/static) to integrate measurement functionality into other
 software (libhipercontracer); open source and written in a performance-
 and portability-focused programming language (C++) with only limited
 dependencies.
 .
 Furthermore, the HiPerConTracer Framework furthermore provides additional
 tools for helping to obtain, process, collect, store, and retrieve
 measurement data: HiPerConTracer Viewer Tool for displaying the contents
 of results files; Results Tool for merging and converting results files,
 e.g. to create a Comma-Separated Value (CSV) file; Sync Tool for copying data
 from a measurement node (vantage point) to a remote HiPerConTracer Collector
 server (via RSync/SSH); Reverse Tunnel Tool for maintaining a reverse SSH
 tunnel from a remote measurement node to a HiPerConTracer Collector server;
 Collector/Node Tools for simplifying the setup of HiPerConTracer Nodes and a
 HiPerConTracer Collector server; Trigger Tool for triggering HiPerConTracer
 measurements in the reverse direction; Importer Tool for storing measurement
 data from results files into SQL or NoSQL databases. Currently, database
 backends for MariaDB/MySQL PostgreSQL, MongoDB) are provided; Query
 Tool for querying data from a database and storing it into a results
 file; Database Shell as simple command-line front-end for the underlying
 database backends; Database Tools with some helper scripts to e.g. to join
 HiPerConTracer database configurations into an existing DBeaver (a popular
 SQL database GUI application) configuration; UDP Echo Server as UDP Echo
 (RFC 862) protocol endpoint; Wireshark dissector for HiPerConTracer packets.
 .
 This is the HiPerConTracer Collector Tools package. It contains helper scripts
 to set up and maintain a HiPerConTracer Collector server.

Package: hipercontracer-importer
Architecture: any
Depends: acl,
         hipercontracer-common,
         libuniversalimporter2 (= ${binary:Version}),
         ${misc:Depends},
         ${shlibs:Depends}
Recommends: hipercontracer,
            hipercontracer-dbshell
Suggests: python3
Description: HiPerConTracer Importer for importing results into a database
 High-Performance Connectivity Tracer (HiPerConTracer) is a Ping/Traceroute
 measurement framework. HiPerConTracer denotes the actual measurement
 tool. It performs regular Ping and Traceroute runs among sites, featuring:
 multi-transport-protocol support (ICMP, UDP); multi-homing and parallelism
 support; handling of load balancing in the network; multi-platform
 support (currently Linux and FreeBSD); high-precision (nanoseconds)
 timing support (Linux timestamping, both software and hardware); a
 library (shared/static) to integrate measurement functionality into other
 software (libhipercontracer); open source and written in a performance-
 and portability-focused programming language (C++) with only limited
 dependencies.
 .
 Furthermore, the HiPerConTracer Framework furthermore provides additional
 tools for helping to obtain, process, collect, store, and retrieve
 measurement data: HiPerConTracer Viewer Tool for displaying the contents
 of results files; Results Tool for merging and converting results files,
 e.g. to create a Comma-Separated Value (CSV) file; Sync Tool for copying data
 from a measurement node (vantage point) to a remote HiPerConTracer Collector
 server (via RSync/SSH); Reverse Tunnel Tool for maintaining a reverse SSH
 tunnel from a remote measurement node to a HiPerConTracer Collector server;
 Collector/Node Tools for simplifying the setup of HiPerConTracer Nodes and a
 HiPerConTracer Collector server; Trigger Tool for triggering HiPerConTracer
 measurements in the reverse direction; Importer Tool for storing measurement
 data from results files into SQL or NoSQL databases. Currently, database
 backends for MariaDB/MySQL PostgreSQL, MongoDB) are provided; Query
 Tool for querying data from a database and storing it into a results
 file; Database Shell as simple command-line front-end for the underlying
 database backends; Database Tools with some helper scripts to e.g. to join
 HiPerConTracer database configurations into an existing DBeaver (a popular
 SQL database GUI application) configuration; UDP Echo Server as UDP Echo
 (RFC 862) protocol endpoint; Wireshark dissector for HiPerConTracer packets.
 .
 This package contains the HiPerConTracer Importer Tool to import data from
 HiPerConTracer results files into an SQL or NoSQL database.

Package: hipercontracer-query
Architecture: any
Provides: hipercontracer-query-tool
Replaces: hipercontracer-query-tool
Breaks: hipercontracer-query-tool (<< ${source:Version})
Depends: hipercontracer-common,
         libuniversalimporter2 (= ${binary:Version}),
         ${misc:Depends},
         ${shlibs:Depends}
Recommends: hipercontracer,
            hipercontracer-dbshell,
            hipercontracer-results,
            hipercontracer-viewer
Description: HiPerConTracer Query Tool to query results from a database
 High-Performance Connectivity Tracer (HiPerConTracer) is a Ping/Traceroute
 measurement framework. HiPerConTracer denotes the actual measurement
 tool. It performs regular Ping and Traceroute runs among sites, featuring:
 multi-transport-protocol support (ICMP, UDP); multi-homing and parallelism
 support; handling of load balancing in the network; multi-platform
 support (currently Linux and FreeBSD); high-precision (nanoseconds)
 timing support (Linux timestamping, both software and hardware); a
 library (shared/static) to integrate measurement functionality into other
 software (libhipercontracer); open source and written in a performance-
 and portability-focused programming language (C++) with only limited
 dependencies.
 .
 Furthermore, the HiPerConTracer Framework furthermore provides additional
 tools for helping to obtain, process, collect, store, and retrieve
 measurement data: HiPerConTracer Viewer Tool for displaying the contents
 of results files; Results Tool for merging and converting results files,
 e.g. to create a Comma-Separated Value (CSV) file; Sync Tool for copying data
 from a measurement node (vantage point) to a remote HiPerConTracer Collector
 server (via RSync/SSH); Reverse Tunnel Tool for maintaining a reverse SSH
 tunnel from a remote measurement node to a HiPerConTracer Collector server;
 Collector/Node Tools for simplifying the setup of HiPerConTracer Nodes and a
 HiPerConTracer Collector server; Trigger Tool for triggering HiPerConTracer
 measurements in the reverse direction; Importer Tool for storing measurement
 data from results files into SQL or NoSQL databases. Currently, database
 backends for MariaDB/MySQL PostgreSQL, MongoDB) are provided; Query
 Tool for querying data from a database and storing it into a results
 file; Database Shell as simple command-line front-end for the underlying
 database backends; Database Tools with some helper scripts to e.g. to join
 HiPerConTracer database configurations into an existing DBeaver (a popular
 SQL database GUI application) configuration; UDP Echo Server as UDP Echo
 (RFC 862) protocol endpoint; Wireshark dissector for HiPerConTracer packets.
 .
 This package contains HiPerConTracer Query Tool to retrieve results from a
 HiPerConTracer SQL or NoSQL database.

Package: hipercontracer-results
Architecture: any
Provides: hipercontracer-results-tool
Replaces: hipercontracer-results-tool
Breaks: hipercontracer-results-tool (<< ${source:Version})
Depends: hipercontracer-common,
         hipercontracer-viewer,
         ${misc:Depends},
         ${shlibs:Depends}
Recommends: hipercontracer
Description: HiPerConTracer Results Tool to process results files
 High-Performance Connectivity Tracer (HiPerConTracer) is a Ping/Traceroute
 measurement framework. HiPerConTracer denotes the actual measurement
 tool. It performs regular Ping and Traceroute runs among sites, featuring:
 multi-transport-protocol support (ICMP, UDP); multi-homing and parallelism
 support; handling of load balancing in the network; multi-platform
 support (currently Linux and FreeBSD); high-precision (nanoseconds)
 timing support (Linux timestamping, both software and hardware); a
 library (shared/static) to integrate measurement functionality into other
 software (libhipercontracer); open source and written in a performance-
 and portability-focused programming language (C++) with only limited
 dependencies.
 .
 Furthermore, the HiPerConTracer Framework furthermore provides additional
 tools for helping to obtain, process, collect, store, and retrieve
 measurement data: HiPerConTracer Viewer Tool for displaying the contents
 of results files; Results Tool for merging and converting results files,
 e.g. to create a Comma-Separated Value (CSV) file; Sync Tool for copying data
 from a measurement node (vantage point) to a remote HiPerConTracer Collector
 server (via RSync/SSH); Reverse Tunnel Tool for maintaining a reverse SSH
 tunnel from a remote measurement node to a HiPerConTracer Collector server;
 Collector/Node Tools for simplifying the setup of HiPerConTracer Nodes and a
 HiPerConTracer Collector server; Trigger Tool for triggering HiPerConTracer
 measurements in the reverse direction; Importer Tool for storing measurement
 data from results files into SQL or NoSQL databases. Currently, database
 backends for MariaDB/MySQL PostgreSQL, MongoDB) are provided; Query
 Tool for querying data from a database and storing it into a results
 file; Database Shell as simple command-line front-end for the underlying
 database backends; Database Tools with some helper scripts to e.g. to join
 HiPerConTracer database configurations into an existing DBeaver (a popular
 SQL database GUI application) configuration; UDP Echo Server as UDP Echo
 (RFC 862) protocol endpoint; Wireshark dissector for HiPerConTracer packets.
 .
 This package contains the HiPerConTracer Results Tool to process
 HiPerConTracer results files, particularly for converting them to CSV files
 for reading them into spreadsheets, analysis tools, etc.

Package: hipercontracer-viewer
Architecture: all
Provides: hipercontracer-viewer-tool
Replaces: hipercontracer-viewer-tool
Breaks: hipercontracer-viewer-tool (<< ${source:Version})
Depends: bzip2,
         hipercontracer-common,
         less,
         xz-utils,
         zstd,
         ${misc:Depends},
         ${shlibs:Depends}
Recommends: hipercontracer,
            hipercontracer-results,
            tree
Description: HiPerConTracer Viewer Tool to display results files
 High-Performance Connectivity Tracer (HiPerConTracer) is a Ping/Traceroute
 measurement framework. HiPerConTracer denotes the actual measurement
 tool. It performs regular Ping and Traceroute runs among sites, featuring:
 multi-transport-protocol support (ICMP, UDP); multi-homing and parallelism
 support; handling of load balancing in the network; multi-platform
 support (currently Linux and FreeBSD); high-precision (nanoseconds)
 timing support (Linux timestamping, both software and hardware); a
 library (shared/static) to integrate measurement functionality into other
 software (libhipercontracer); open source and written in a performance-
 and portability-focused programming language (C++) with only limited
 dependencies.
 .
 Furthermore, the HiPerConTracer Framework furthermore provides additional
 tools for helping to obtain, process, collect, store, and retrieve
 measurement data: HiPerConTracer Viewer Tool for displaying the contents
 of results files; Results Tool for merging and converting results files,
 e.g. to create a Comma-Separated Value (CSV) file; Sync Tool for copying data
 from a measurement node (vantage point) to a remote HiPerConTracer Collector
 server (via RSync/SSH); Reverse Tunnel Tool for maintaining a reverse SSH
 tunnel from a remote measurement node to a HiPerConTracer Collector server;
 Collector/Node Tools for simplifying the setup of HiPerConTracer Nodes and a
 HiPerConTracer Collector server; Trigger Tool for triggering HiPerConTracer
 measurements in the reverse direction; Importer Tool for storing measurement
 data from results files into SQL or NoSQL databases. Currently, database
 backends for MariaDB/MySQL PostgreSQL, MongoDB) are provided; Query
 Tool for querying data from a database and storing it into a results
 file; Database Shell as simple command-line front-end for the underlying
 database backends; Database Tools with some helper scripts to e.g. to join
 HiPerConTracer database configurations into an existing DBeaver (a popular
 SQL database GUI application) configuration; UDP Echo Server as UDP Echo
 (RFC 862) protocol endpoint; Wireshark dissector for HiPerConTracer packets.
 .
 This package contains the HiPerConTracer Viewer Tool to display
 HiPerConTracer results files.

Package: hipercontracer-udp-echo-server
Architecture: any
Depends: ${misc:Depends},
         ${shlibs:Depends}
Recommends: hipercontracer
Description: HiPerConTracer UDP Echo server for responding to UDP Pings
 High-Performance Connectivity Tracer (HiPerConTracer) is a Ping/Traceroute
 measurement framework. HiPerConTracer denotes the actual measurement
 tool. It performs regular Ping and Traceroute runs among sites, featuring:
 multi-transport-protocol support (ICMP, UDP); multi-homing and parallelism
 support; handling of load balancing in the network; multi-platform
 support (currently Linux and FreeBSD); high-precision (nanoseconds)
 timing support (Linux timestamping, both software and hardware); a
 library (shared/static) to integrate measurement functionality into other
 software (libhipercontracer); open source and written in a performance-
 and portability-focused programming language (C++) with only limited
 dependencies.
 .
 Furthermore, the HiPerConTracer Framework furthermore provides additional
 tools for helping to obtain, process, collect, store, and retrieve
 measurement data: HiPerConTracer Viewer Tool for displaying the contents
 of results files; Results Tool for merging and converting results files,
 e.g. to create a Comma-Separated Value (CSV) file; Sync Tool for copying data
 from a measurement node (vantage point) to a remote HiPerConTracer Collector
 server (via RSync/SSH); Reverse Tunnel Tool for maintaining a reverse SSH
 tunnel from a remote measurement node to a HiPerConTracer Collector server;
 Collector/Node Tools for simplifying the setup of HiPerConTracer Nodes and a
 HiPerConTracer Collector server; Trigger Tool for triggering HiPerConTracer
 measurements in the reverse direction; Importer Tool for storing measurement
 data from results files into SQL or NoSQL databases. Currently, database
 backends for MariaDB/MySQL PostgreSQL, MongoDB) are provided; Query
 Tool for querying data from a database and storing it into a results
 file; Database Shell as simple command-line front-end for the underlying
 database backends; Database Tools with some helper scripts to e.g. to join
 HiPerConTracer database configurations into an existing DBeaver (a popular
 SQL database GUI application) configuration; UDP Echo Server as UDP Echo
 (RFC 862) protocol endpoint; Wireshark dissector for HiPerConTracer packets.
 .
 This package contains a simple UDP Echo server to respond to UDP Pings.

Package: hipercontracer-dbshell
Architecture: all
Depends: ${misc:Depends}
Recommends: hipercontracer,
            hipercontracer-dbeaver-tools,
            mariadb-client | default-mysql-client,
            mongodb-mongosh,
            postgresql-client,
            pwgen
Description: HiPerConTracer Database Shell for access testing to a database
 High-Performance Connectivity Tracer (HiPerConTracer) is a Ping/Traceroute
 measurement framework. HiPerConTracer denotes the actual measurement
 tool. It performs regular Ping and Traceroute runs among sites, featuring:
 multi-transport-protocol support (ICMP, UDP); multi-homing and parallelism
 support; handling of load balancing in the network; multi-platform
 support (currently Linux and FreeBSD); high-precision (nanoseconds)
 timing support (Linux timestamping, both software and hardware); a
 library (shared/static) to integrate measurement functionality into other
 software (libhipercontracer); open source and written in a performance-
 and portability-focused programming language (C++) with only limited
 dependencies.
 .
 Furthermore, the HiPerConTracer Framework furthermore provides additional
 tools for helping to obtain, process, collect, store, and retrieve
 measurement data: HiPerConTracer Viewer Tool for displaying the contents
 of results files; Results Tool for merging and converting results files,
 e.g. to create a Comma-Separated Value (CSV) file; Sync Tool for copying data
 from a measurement node (vantage point) to a remote HiPerConTracer Collector
 server (via RSync/SSH); Reverse Tunnel Tool for maintaining a reverse SSH
 tunnel from a remote measurement node to a HiPerConTracer Collector server;
 Collector/Node Tools for simplifying the setup of HiPerConTracer Nodes and a
 HiPerConTracer Collector server; Trigger Tool for triggering HiPerConTracer
 measurements in the reverse direction; Importer Tool for storing measurement
 data from results files into SQL or NoSQL databases. Currently, database
 backends for MariaDB/MySQL PostgreSQL, MongoDB) are provided; Query
 Tool for querying data from a database and storing it into a results
 file; Database Shell as simple command-line front-end for the underlying
 database backends; Database Tools with some helper scripts to e.g. to join
 HiPerConTracer database configurations into an existing DBeaver (a popular
 SQL database GUI application) configuration; UDP Echo Server as UDP Echo
 (RFC 862) protocol endpoint; Wireshark dissector for HiPerConTracer packets.
 .
 This package contains a simple tool to start a database shell, based on the
 settings from a given database configuration file. It is mainly intended to
 test database access using the configuration files for HiPerConTracer Importer
 and HiPerConTracer Query Tool.

Package: hipercontracer-dbeaver-tools
Architecture: all
Depends: hipercontracer-dbshell (>= ${source:Version}),
         jq,
         openssl,
         ${misc:Depends}
Description: HiPerConTracer DBeaver Tools for configuring access to databases
 High-Performance Connectivity Tracer (HiPerConTracer) is a Ping/Traceroute
 measurement framework. HiPerConTracer denotes the actual measurement
 tool. It performs regular Ping and Traceroute runs among sites, featuring:
 multi-transport-protocol support (ICMP, UDP); multi-homing and parallelism
 support; handling of load balancing in the network; multi-platform
 support (currently Linux and FreeBSD); high-precision (nanoseconds)
 timing support (Linux timestamping, both software and hardware); a
 library (shared/static) to integrate measurement functionality into other
 software (libhipercontracer); open source and written in a performance-
 and portability-focused programming language (C++) with only limited
 dependencies.
 .
 Furthermore, the HiPerConTracer Framework furthermore provides additional
 tools for helping to obtain, process, collect, store, and retrieve
 measurement data: HiPerConTracer Viewer Tool for displaying the contents
 of results files; Results Tool for merging and converting results files,
 e.g. to create a Comma-Separated Value (CSV) file; Sync Tool for copying data
 from a measurement node (vantage point) to a remote HiPerConTracer Collector
 server (via RSync/SSH); Reverse Tunnel Tool for maintaining a reverse SSH
 tunnel from a remote measurement node to a HiPerConTracer Collector server;
 Collector/Node Tools for simplifying the setup of HiPerConTracer Nodes and a
 HiPerConTracer Collector server; Trigger Tool for triggering HiPerConTracer
 measurements in the reverse direction; Importer Tool for storing measurement
 data from results files into SQL or NoSQL databases. Currently, database
 backends for MariaDB/MySQL PostgreSQL, MongoDB) are provided; Query
 Tool for querying data from a database and storing it into a results
 file; Database Shell as simple command-line front-end for the underlying
 database backends; Database Tools with some helper scripts to e.g. to join
 HiPerConTracer database configurations into an existing DBeaver (a popular
 SQL database GUI application) configuration; UDP Echo Server as UDP Echo
 (RFC 862) protocol endpoint; Wireshark dissector for HiPerConTracer packets.
 .
 This package contains helper scripts to merge HiPerConTracer database
 configurations into DBeaver configurations, for maintaining databases
 in DBeaver.

Package: hipercontracer-all
Architecture: all
Depends: hipercontracer,
         hipercontracer-dbeaver-tools,
         hipercontracer-dbshell,
         hipercontracer-importer,
         hipercontracer-query-tool,
         hipercontracer-results-tool,
         hipercontracer-sync-tool,
         hipercontracer-trigger,
         hipercontracer-udp-echo-server,
         hipercontracer-viewer-tool,
         ${misc:Depends}
Description: HiPerConTracer metapackage for all tools of the framework
 High-Performance Connectivity Tracer (HiPerConTracer) is a Ping/Traceroute
 measurement framework. HiPerConTracer denotes the actual measurement
 tool. It performs regular Ping and Traceroute runs among sites, featuring:
 multi-transport-protocol support (ICMP, UDP); multi-homing and parallelism
 support; handling of load balancing in the network; multi-platform
 support (currently Linux and FreeBSD); high-precision (nanoseconds)
 timing support (Linux timestamping, both software and hardware); a
 library (shared/static) to integrate measurement functionality into other
 software (libhipercontracer); open source and written in a performance-
 and portability-focused programming language (C++) with only limited
 dependencies.
 .
 Furthermore, the HiPerConTracer Framework furthermore provides additional
 tools for helping to obtain, process, collect, store, and retrieve
 measurement data: HiPerConTracer Viewer Tool for displaying the contents
 of results files; Results Tool for merging and converting results files,
 e.g. to create a Comma-Separated Value (CSV) file; Sync Tool for copying data
 from a measurement node (vantage point) to a remote HiPerConTracer Collector
 server (via RSync/SSH); Reverse Tunnel Tool for maintaining a reverse SSH
 tunnel from a remote measurement node to a HiPerConTracer Collector server;
 Collector/Node Tools for simplifying the setup of HiPerConTracer Nodes and a
 HiPerConTracer Collector server; Trigger Tool for triggering HiPerConTracer
 measurements in the reverse direction; Importer Tool for storing measurement
 data from results files into SQL or NoSQL databases. Currently, database
 backends for MariaDB/MySQL PostgreSQL, MongoDB) are provided; Query
 Tool for querying data from a database and storing it into a results
 file; Database Shell as simple command-line front-end for the underlying
 database backends; Database Tools with some helper scripts to e.g. to join
 HiPerConTracer database configurations into an existing DBeaver (a popular
 SQL database GUI application) configuration; UDP Echo Server as UDP Echo
 (RFC 862) protocol endpoint; Wireshark dissector for HiPerConTracer packets.
 .
 This metapackage installs all sub-packages of the HiPerConTracer Framework.
